Efficient context monitoring

ABSTRACT

Disclosed are systems, methods, and non-transitory computer-readable storage media for efficiently monitoring the operating context of a computing device. In some implementations, the context daemon and/or the context client can be terminated to conserve system resources. For example, if the context daemon and/or the context client are idle, they can be shutdown to conserve battery power or free other system resources (e.g., memory). When an event occurs (e.g., a change in current context) that requires the context daemon and/or the context client to be running, the context daemon and/or the context client can be restarted to handle the event. Thus, system resources can be conserved while still providing relevant context information collection and callback notification features.

RELATED APPLICATIONS

This application claims priority to U.S. Provisional Patent ApplicationNo. 62/171,892, filed on Jun. 5, 2015, entitled “DEVICE CONTEXTMONITORING; CONTEXT NOTIFICATIONS; CONTEXT PREDICTION; EFFICIENT CONTEXTMONITORING ,” the content of which is incorporated herein by referencein its entirety.

TECHNICAL FIELD

This disclosure generally relates to efficiently monitoring theoperating context of a computing device.

BACKGROUND

Software processes executing on a computing device use device stateinformation to perform various functions on the computing device. Anoperating system process on the computing device can use battery chargestate information to warn the user about a potential power failure. Alocation-based application can use location state information todetermine when to present information for a nearby business. A musicapplication can determine how to output sound based on state informationthat describes the type of speaker, headphones, or other sound-producingdevice connected to the computing device. To obtain this device stateinformation, the software processes (e.g., operating system,application, utility, etc.) must be configured (e.g., programmed) toaccess various application programming interfaces (APIs) to accessvarious different sources of device state information. To detect changesin device state, the software systems must be programmed to periodicallyobtain updated device state information and analyze the device stateinformation for changes in device state. The programmers of thesesoftware systems are often burdened with learning many different APIs toobtain the device state information needed by the software systems.Additionally, the programmers must write the code to periodically checkthe state of the system components. Moreover, the various softwaresystems waste processing time and resources by duplicating the codeneeded to periodically check and detect changes in device state.

SUMMARY

Disclosed are systems, methods, and non-transitory computer-readablestorage media for monitoring the current context of a computing device.In some embodiments, a context daemon can collect context informationabout the computing device. The context information can include currentdevice hardware state information. The context information can includecurrent software state information. The context can be derived orimplied from a combination of hardware state information, software stateinformation, or any other type of state information. For example, thederived context can be a user state (e.g., a user activity, sleeping,running, etc.) derived from or implied by hardware or software stateinformation.

In some embodiments, context information can be reported to the contextdaemon by context monitors. The context monitors can be specificallybuilt for collecting context information monitored by the contextdaemon. The context monitors can be applications, utilities, tools, orthe like that were built for other purposes, use or generate hardware orsoftware state information, and report the state information to thecontext daemon. Once the context information has been collected, thecontext daemon can store the current context of the computing device ina central location so that context clients (e.g., software,applications, utilities, operating system, etc.) can obtain currentcontext information from a single source. In some embodiments, thecontext daemon can generate and/or collect historical contextinformation. The historical context information can include the old oroutdated context information. The historical context information can bederived from the context information. Thus, the context daemon canprovide a central repository of context information that context clients(e.g., processes) can use to determine the current context of thecomputing device.

Disclosed are systems, methods, and non-transitory computer-readablestorage media for notifying context clients of changes to the currentcontext of a computing device. In some embodiments, a context client canregister to be called back when the context daemon detects specifiedcontext. For example, the context client can specify a context in whichthe context client is interested. When the context daemon detects thatthe current context of the computing device corresponds to theregistered context, the context daemon can notify the context clientthat the current context matches the context in which the context clientis interested. Thus, context clients do not require the programmingnecessary to independently obtain context updates and detect changes incontext that are relevant or of interest to the context client.

Disclosed are systems, methods, and non-transitory computer-readablestorage media for efficiently monitoring the operating context of acomputing device. In some embodiments, the context daemon and/or thecontext client can be terminated to conserve system resources. Forexample, if the context daemon and/or the context client are idle, theycan be shutdown to conserve battery power or free other system resources(e.g., memory). When an event occurs (e.g., a change in current context)that requires the context daemon and/or the context client to berunning, the context daemon and/or the context client can be restartedto handle the event. Thus, system resources can be conserved while stillproviding relevant context information collection and callbacknotification features.

Disclosed are systems, methods, and non-transitory computer-readablestorage media for predicting a future context of a computing device. Insome embodiments, a context daemon can use historical contextinformation to predict future events and/or context changes. Forexample, the context daemon can analyze historical context informationto predict user sleep patterns, user exercise patterns, and/or otheruser activity. In some embodiments, a context client can register acallback for a predicted future context. For example, the context clientcan request to be notified ten minutes in advance of a predicted eventand/or context change. The context daemon can use the prediction tonotify a context client in advance of the predicted event.

BRIEF DESCRIPTION OF THE DRAWINGS

The above recited and other features of the disclosure will becomeapparent by reference to specific embodiments thereof that areillustrated in the appended drawings. Understanding that these drawingsdepict only example embodiments of the technology described herein andtherefore do not limit its scope, the principles herein are describedand explained with additional specificity and detail through the use ofthe accompanying drawings in which:

FIG. 1 is a block diagram of an example system for monitoring,predicting, and notifying context clients of changes in the currentcontext of a computing device;

FIG. 2A illustrates an example of context items that can make up thecurrent context;

FIG. 2B illustrates an example of a new context item being added to thecurrent context;

FIG. 3 illustrates an example callback predicate database;

FIG. 4 is a graph that illustrates example state changes associated withcontext items over time;

FIG. 5 is a graph that illustrates example event streams associated withcontext items;

FIG. 6 illustrates an example historical event stream database;

FIG. 7 is a block diagram of an example system for providing a contextcallback notification to a requesting client;

FIG. 8A is a block diagram of an example system illustrating restartinga requesting client that has been terminated;

FIG. 8B is a block diagram of an example system illustrating restartinga requesting client that has been terminated;

FIG. 9A is a block diagram of an example system illustrating restartinga context daemon that has been terminated;

FIG. 9B is a block diagram of an example system illustrating restartinga context daemon that has been terminated;

FIG. 10A is a block diagram of an example system illustrating restartinga context daemon and a requesting client that have been terminated;

FIG. 10B is a block diagram of an example system illustrating restartinga context daemon and a requesting client that have been terminated;

FIG. 11 is a block diagram of an example system configured to restart aclient and/or a context daemon based on device state informationreceived by a launch daemon.

FIG. 12A is a block diagram of an example system illustrating restartinga context daemon using a launch daemon;

FIG. 12B is a block diagram of an example system illustrating restartinga context daemon using a launch daemon;

FIG. 13A is a block diagram of an example system illustrating restartinga requesting client using a launch daemon;

FIG. 13B is a block diagram of an example system illustrating restartinga requesting client using a launch daemon;

FIG. 14 is a graph that illustrates an example of slot-wise averaging topredict future events;

FIG. 15 depicts example graphs illustrating slot weighting;

FIG. 16A is a series of graphs illustrating an example method forpredicting a future context;

FIG. 16B is a cumulative graph illustrating an example method forpredicting a future context;

FIG. 16C is a series of graphs illustrating an example method forpredicting a future context using a probability curve;

FIG. 16D is a cumulative graph illustrating an example method forpredicting a future context using a probability curve;

FIG. 17 illustrates an example event stream that includes a predictedfuture event;

FIG. 18 is a flow diagram of an example process for notifying clients ofcontext changes on a computing device;

FIG. 19 is a flow diagram of an example process for restarting a contextdaemon to service a callback request;

FIG. 20 is a flow diagram of an example process for restarting acallback client to receive a callback notification;

FIG. 21 is a flow diagram of an example process for predicting futureevents based on historical context information;

FIG. 22 is a flow diagram of an example process for servicing a sleepcontext callback request;

FIG. 23A shows an example system architecture for implementing thevarious systems and processes described herein; and

FIG. 23B shows an example system architecture for implementing thevarious systems and processes described herein.

DETAILED DESCRIPTION Determining the Current Context

FIG. 1 is a block diagram of an example system 100 for monitoring,predicting, and notifying context clients of changes in the operationalcontext of a computing device. The computing device can be, for example,a desktop computer, laptop computer, smartphone, tablet computer, or anyother type of computing device. System 100 can be configured to run onthe computing device, for example. In some embodiments, system 100 caninclude context daemon 102. For example, context daemon 102 can be abackground process executing on the computing device. Context daemon 102can be a process included in the operating system of the computingdevice, for example.

In some embodiments, context daemon 102 can be configured to collectinformation about the current operating context of the computing device.For example, the context information can include information thatdescribes the internal and/or external context of the computing device.In some embodiments, internal context information can include hardwarestate information. For example, the hardware state information canidentify hardware that is in use and how the hardware is being used. Ifthe hardware is a wireless transceiver being used to communicate withanother device, the hardware state information can identify the otherdevice, when the connection was created, how much data has beentransmitted, etc. In some embodiments, the internal context informationcan include software state information. For example, the stateinformation for a calendar application can include calendar events,meetings, names of contacts who will participate in the meetings, startand finish times for the meetings, etc.

In some embodiments, the external context information can include a useractivity. For example, the external context information can be derivedfrom the hardware state information and/or the software stateinformation. For example, context daemon 102 can derive user behavior(e.g., sleep patterns, work patterns, eating patterns, travel patterns,etc.) from the hardware and/or software state information, as describedfurther below.

In some embodiments, context daemon 102 can include monitor bundles 104for collecting various types of context information. Each monitor bundle106 in monitor bundles 104 can be configured to collect contextinformation about corresponding context items. For example, monitorbundle 106 can be a process external to context daemon 102. Monitorbundle 106 can be a dynamically loaded software package that can beexecuted within context daemon 102.

In some embodiments, monitor bundle 106 can include context monitor 108.For example, context monitor 108 can be configured to collectinformation about the current context of the computing device. In someembodiments, monitor bundle 106 can include historical monitor 110. Forexample, historical monitor 110 can be configured to collect ordetermine the historical context for the computing device, as describedfurther below.

In some embodiments, each monitor bundle 106 in monitor bundles 104 canbe configured to collect specific types of context information. Forexample, context daemon 102 can load a plurality of different monitorbundles 106. Each monitor bundle 106 can be configured to collectdifferent context information from different sources 130 within thecomputing device. For example, one monitor bundle 106 can collectcontext information about a Bluetooth context item while another monitorbundle 106 can collect context information about a lock state contextitem.

In some embodiments, monitor bundle 106 can be configured to collectdevice location context information from location API 132. For example,context monitor 108 can receive current global navigational satellitesystem (GNSS) location data received by a GNSS receiver from locationAPI 132. Monitor bundle 106 can receive current cellular and/or WiFiderived location data from location API 132.

In some embodiments, monitor bundle 106 can be configured to collectlock state context information from lock state API 134. For example,context monitor 108 can collect lock state context information thatdescribes the current lock state (e.g., locked, unlocked, etc.) of thecomputing device. For example, a user of the computing device mustunlock the computing device to use or interact with the computingdevice. When the device is locked, the device can be configured to notaccept user input. When the device is unlocked, the device can beconfigured to accept user input. For handheld devices with touchscreendisplays, when the device is unlocked, the display can be illuminatedand can accept touch input from the user. When the touchscreen device islocked, the display can be dark and the touchscreen display will notaccept touch input. Thus, the lock state of the computing device canprovide evidence that the user has interacted with the computing device.

In some embodiments, monitor bundle 106 can be configured to collectapplication context information from application manager API 136. Forexample, context monitor 108 can receive from application manager API136 information describing which applications are currently running onthe computing device, how long the applications have been running, whenthe applications were invoked, and/or which application is currently theapplication in focus (e.g., in the foreground, visible on the display).

In some embodiments, monitor bundle 106 can be configured to collectBluetooth context information from Bluetooth API 138. For example,context monitor 108 can receive from Bluetooth API 138 informationdescribing an active Bluetooth connection, including the identificationand type of Bluetooth device connected to the computing device, when theconnection was established, and the how long (e.g., duration) thecomputing device has been connected to the Bluetooth device.

In some embodiments, monitor bundle 106 can be configured to collectheadphone jack information from headphone API 140. For example, contextmonitor 108 can receive from headphone API 140 information thatdescribes whether a wired headphone or headset (or other device) iscurrently connected to the headphone jack of the computing device. Insome embodiments, monitor bundle 106 can receive information about thetype of device connected to the headphone jack from headphone API 140.

In some embodiments, monitor bundle 106 can be configured to collectother context information from other device state APIs 142. For example,context monitor 108 can receive from other state APIs 138 informationthat describes WiFi connections, telephone connections, applicationusage, calendar events, photographs, media usage information, batterycharging state, and/or any other state information that can be used todescribe or infer the current internal and/or external context of thecomputing device.

In some embodiments, monitor bundle 106 can be dynamically loaded intocontext daemon 102 as needed. For example, when location contextinformation is needed (e.g., a client has requested locationinformation) by context daemon 102, then context daemon 102 can load alocation-specific monitor bundle 106 into monitor bundles 104. Onceloaded, context monitor 108 of monitor bundle 106 can start collectingcurrent location-specific context. By loading monitor bundles 106 asneeded, context daemon 102 can conserve system resources of thecomputing device, such as memory and battery power. In some embodiments,monitor bundle 106 can be an external process, such as reporting client124. Context daemon 102 can invoke the external process monitor bundle106 as needed to collect context information. For example, contextdaemon 102 can load or invoke monitor bundle 106 in response toreceiving a callback request, as described below.

In some embodiments, context daemon 102 can receive context informationfrom reporting client 124. For example, reporting client 124 (contextclient) can be any software running on the computing device thatgenerates or collects context information and reports the contextinformation to context daemon 102. For example, a map applicationrunning on the computing device can obtain location information usinglocation API 132 to determine how to route the user from a startinglocation to a destination location. In addition to determining theroute, the map application can report the location information obtainedfrom location API 132 to context daemon 102. Thus, while reportingclient 124 is not built for the purpose of collecting and reportingcontext information like monitor bundle 106, reporting client 124 can beconfigured to report context information when reporting client 124obtains the context information while performing its primary function.

In some embodiments, context daemon 102 can include current context 112.For example, current context 112 can be an in-memory repository ofcontext information received from monitor bundles 104 (e.g., monitorbundle 106) and/or reporting client 124. When monitor bundles 104 and/orreporting client 124 report context information to context daemon 102,context daemon 102 can update current context 112 with the newlyreceived context information. Thus, current context 112 can includecontext information (e.g., context items) describing the current contextof the computing device.

FIG. 2A and FIG. 2B illustrate example current contexts 200 and 250.FIG. 2A illustrates an example of context items that can make up currentcontext 200. For example, current context 200 (e.g., current context112) can include context information for the computing device at timeTO. For example, current context 200 can include a context item thatrepresents the current locked state (false). Current context 200 caninclude a context item that represents the plugged in state of theheadphone jack (false). Current context 200 can include a context itemthat represents the charging state of the battery (false). Currentcontext 200 can include a context item that represents the connectionstate of the Bluetooth transceiver (false). Current context 200 caninclude a context item that identifies the application currently infocus on the computing device (social app). The context informationshown in current context 200 can be received from monitor bundle 106and/or from reporting client 124, for example.

FIG. 2B illustrates an example of a new context item being added tocurrent context 250. Current context 250 (e.g., current context 112) caninclude context information for the computing device at some later timeT 1. For example, current context 250 includes a new context item thatidentifies the current location of the computing device. The newlocation context item can be added when a new location monitor bundle106 is loaded into context daemon 102 and starts reporting locationcontext information to context daemon 102. For example, the new locationmonitor bundle 106 can be loaded in response to a request from a contextclient for location information.

Callback Requests

Referring to FIG. 1, in some embodiments, context daemon 102 can exposean API that allows context client software running on the computingdevice to access (e.g., query, view, etc.) the information in currentcontext 112. In some embodiments, context daemon 102 can receive arequest from requesting client 126 (e.g., context client) to callbackregistry 114 when a specific context is detected by context daemon 102.For example, requesting client 126 can send a callback request tocontext daemon 102. Context daemon 102 can store the callback requestinformation in callback registry 114. Callback registry 114 can be anin-memory repository of callback information. For example, the callbackrequest can specify a predicate (e.g., a context condition) fornotifying requesting client 126. The callback request can include aclient identifier for requesting client 126.

In some embodiments, when the callback request is received, callbackregistry 114 can generate a unique identifier for the callback requestand store the callback request identifier, the client identifier, andcallback predicate in callback predicate database 116. Context daemon102 can return the callback request identifier to requesting client 126in response to receiving the callback request. When the contextinformation in current context 112 satisfies the predicate, contextdaemon 102 will notify requesting client 126. For example, the callbacknotification can include the callback request identifier so thatrequesting client 126 can determine the callback request correspondingto the notification. For example, requesting client 126 can registermany callback requests with context daemon 102. When callback daemon 102sends a callback notification to requesting client 126, requestingclient 126 can use the callback request identifier to determine to whichcallback request the callback notification relates.

In some embodiments, context daemon 102 can load monitor bundle 106 inresponse to receiving a callback request from requesting client 126. Forexample, context daemon 102 can support lazy initialization of monitorbundles 106. In other words, context daemon 102 can load and initializemonitor bundle 106 when needed to service a callback request. Forexample, if no client is interested in location information, thencontext daemon 102 can be configured to not load a location monitorbundle 106 so that system resources (e.g., battery, memory, etc.) arenot wasted monitoring a context item that is not needed. However, uponreceipt of a callback request for the location context item, contentdaemon 102 can load, initialize, or invoke the monitor bundle 106associated with the location context item and start receiving contextinformation regarding the location of the computing device.

In some embodiments, monitor bundle 106 can be a software plugin forcontext daemon 102. For example, monitor bundle 106 can be software code(e.g., library, object code, java jar file, etc.) that can bedynamically loaded into context daemon 102 and executed to monitorcontext information. In some embodiments, monitor bundle 106 can be aseparate process external to context daemon 102. For example, monitorbundle 106 can be a standalone executable that context daemon 102 caninvoke to monitor and report context information.

FIG. 3 illustrates an example callback predicate database 300. Forexample, predicate database 300 can correspond to predicate database 116of FIG. 1. In some embodiments, each entry 302-316 in predicate database300 can include a callback request identifier. For example, when contextdaemon 102 receives a callback request from requesting client 126,context daemon 102 can generate a unique request identifier for thecallback request. As described above, context daemon 102 can return thecallback request identifier to requesting client 126 in response to thecallback request. Context daemon 102 can associate the generatedcallback request identifier (“Request ID”) with the client identifier(“Client ID”), the callback predicate (“Predicate”), and the conditionfor callback (“Callback Condition”) in the callback predicate database,as shown in FIG. 3. When the context daemon 102 sends a callbacknotification to requesting client 126, context daemon 102 can includethe callback identifier in the notification so that requesting client126 can determine why context daemon 102 is sending the callbacknotification. For example, requesting client 126 can send multiplecallback requests to context daemon 102. Requesting client 126 candetermine for which callback request context daemon 102 is sending anotification based on the callback request identifier.

In some embodiments, each entry 302-316 in predicate database 300 caninclude a client identifier and a callback predicate. The clientidentifier can correspond to the client that requested to be notified(e.g., called back) when the current context of the computing devicesatisfies the corresponding predicate specified by requesting client126. In some embodiments, the client identifier can be generated by alaunch daemon configured to launch (e.g., execute, invoke, etc.)processes on the computing device, as describe further below. Forexample, entry 302 corresponds to a requesting client 126 having clientidentifier “Client_ID1” that requested to be notified when the currentcontext of the computing device indicates that the device is locked andthat the application in focus is the music application. Stateddifferently, the context client (e.g., requesting client 126)corresponding to client identifier “Client_ID1” specified that thepredicate for notifying (e.g., calling back) the context client is thatthe device is locked and the application currently being used by theuser is the music application. For example, the predicate specified byrequesting client 126 can identify one or more context conditions (e.g.,hardware state values, software state values, derived context, etc.)separated by logical (e.g., Boolean) operators. When the current stateof the computing device corresponds to the specified predicate, contextdaemon 102 will notify (e.g., call back) requesting client 126.

In some embodiments, a predicate can be associated with a callbackcondition (e.g., time component). For example, the callback conditioncan include “before” and/or “after” operators (e.g., terms) that allow arequesting client 126 to indicate an amount of time before or after someevent (e.g., state change, context change, etc.) when the requestingclient 126 should be notified. For example, context daemon 102 canreceive calendar application state information that indicates that ameeting is scheduled at a specific time in the future. Requesting client126 can register a predicate and callback condition (e.g., entry 316)that specifies that context daemon 102 should notify requesting client126 thirty minutes before the meeting. When the current time correspondsto thirty minutes before the meeting, context daemon 102 can send anotification to requesting client 126. Similarly, context daemon 102 canpredict a future event (e.g., user sleep period, user arriving at home,user arriving at the office, user waking up, etc.) based on historicalcontext information. For example, requesting client 126 can register apredicate and callback condition (e.g., entry 306) that specifies thatcontext daemon 102 should notify requesting client 126 thirty minutesbefore a predicted user sleep period. When the current time correspondsto thirty minutes before the predicted sleep period, context daemon 102can send a notification to requesting client 126. Likewise, requestingclient 126 can register a predicate and callback condition (e.g., entry310) that specifies that context daemon 102 should notify requestingclient 126 five minutes after the user is predicted to wake up based onthe predicted sleep period. For example, when the current timecorresponds to five minutes after the user wakes up, context daemon 102can send a notification to requesting client 126. In some embodiments, acallback condition in not provided or provided as immediately uponsatisfaction of the predicate. For example, requesting client 126 canregister a predicate (e.g., entry 304) that specifies that contextdaemon 102 should notify requesting client 126 immediately based on thepredicate unlocked and at home. When requesting client 126 is unlockedand at the location home, context daemon 102 can send a notification torequesting client 126.

Event Streams

Referring to FIG. 1, in some embodiments, context daemon 102 can includehistorical knowledge repository 118. For example, while current context112 includes context information that reflects the current state of thecomputing device, as described above, historical knowledge 118 includeshistorical context information. Historical knowledge 118 can be anin-memory repository of historical context information. For example,historical knowledge 118 can include event streams that representchanges in context (e.g., state) over time. For example, each event orcontext item tracked in current context 112 has a corresponding value.When a context item in current context 112 changes value, the previousvalue can be recorded in historical knowledge 118. By analyzing thestate changes, a start time, and an end time, a duration can becalculated for each context item value.

FIG. 4 is a graph 400 that illustrates example value changes associatedwith context items over time. For example, graph 400 includes currentcontext 402 that indicates the current values for context items (e.g.,locked, headphones, charging, Bluetooth, app in focus, sleeping, andlocation). Graph 400 includes past (e.g., historical) values 404 for thesame context items over time. By analyzing changes in context itemvalues, context daemon 102 can determine start times, end times, anddurations for each value associated with the context items, asillustrated by FIG. 5 below.

FIG. 5 is a graph 500 that illustrates example event streams associatedwith context items. In some embodiments, each state change representedin graph 400 of FIG. 4 can be converted into a data object (e.g., object502) that includes data describing the duration that a particular stateexisted within the system and metadata associated with the state. Insome embodiments, historical monitor 110 can be configured to convertcurrent and/or historical context information into historical eventstream objects. For example, when a value change is detected for acontext item corresponding to a particular monitor bundle 106,historical monitor 110 can generate historical event stream objectsbased on the prior value of the context item. For example, some contextmonitors 106 can be configured to periodically report the state of asoftware and/or hardware component of the computing device. Contextmonitor 106 can be configured to periodically report Bluetooth stateinformation, for example. The reported Bluetooth state information caninclude a sequence of identical state values followed by a state change.For example, context monitor 106 can report that the state of Bluetoothis “off, on, off, off, on.” Historical monitor 110 can combine theseries of “off” Bluetooth context item values, determine the start timeand the end time of the “off” value, and calculate a duration theBluetooth component was in the “off” state.

In some embodiments, historical monitor 110 can collect additionalinformation (e.g., metadata) for event stream objects. For example,continuing the Bluetooth example above, historical monitor 110 candetermine that the Bluetooth context item had an “on” value and requestadditional information from Bluetooth API 138. For example, historicalmonitor 110 can receive from Bluetooth API 138 information identifyingthe type of Bluetooth device connected to the computing device, theBluetooth protocol used, the amount of data transmitted over theBluetooth connection, and/or any other information relevant to theBluetooth connection.

In another example, while context monitor 108 can be configured tocollect current context information (e.g., call information) from atelephony API (e.g., telephone number called, time when call wasinitiated, time when call was terminated, etc.), historical monitor 110can collect event stream metadata for a call from a contacts API (e.g.,name of person called, etc.) or a call history API (e.g., name of personcalled, duration of call, etc.) and add this additional information tothe event stream object for a telephony context item. Thus, historicalmonitor 110 can be configured to generate or collect additional dataabout a historical event to make the historical event (e.g., eventstream, event stream object) more valuable for historical reference andfor predicting future events. Once historical monitor 110 collects orgenerates the event stream metadata, historical monitor 110 can storethe event stream metadata in historical knowledge repository 118. Insome embodiments, context daemon 102 and or historical monitor 110 canstore event stream objects (e.g., including start time, stop time,duration, and/or metadata) in history database 120.

FIG. 6 illustrates an example historical event stream database 600. Forexample, historical event stream database can correspond to historydatabase 120. The example historical event stream database 600represents a conceptual depiction of the historical event stream datastored in history database 600 and may not reflect the actual embodimentof history database 600. A skilled person will recognize that thehistorical event stream data in database 600 can be organized and storedin many different ways.

In some embodiments, history database 600 can include event streamtables 602-614. For example, each event stream table 602-614 cancorrespond to a single event stream (e.g., context item). Each eventstream table (e.g., tables 602-614, etc.) can include records (e.g.,616-626, etc.) corresponding to an event stream object in the eventstream. For example, the “locked” event stream table 602 can includeevent stream object records 616, 618 that describe the locked (orunlocked) state of the “locked” event stream. The event stream objectrecords can include a “start” field that has a timestamp (TS) value thatindicates when the event began. The event stream object records caninclude a “duration” field that indicates the duration (D) of the event.The event stream object records can include state information (e.g.,“locked:false” indicating that the device was not locked) that describesthe state change corresponding to the event.

In some embodiments, the event stream object records can includemetadata that describes other data associated with the event. Forexample, when generating the historical event stream data, historicalmonitor 110 can collect and/or generate metadata that describesadditional attributes of or circumstances surrounding the state of thesystem at the time of the event. For example, for the “charging” eventstream 606, historical monitor 110 can collect information related tothe state of battery charge (e.g., percent charge, charge level, etc.)at the beginning and/or ending of the charging event. For the Bluetoothevent stream 608, historical monitor 110 can collect information relatedto the type of Bluetooth device connected to the computing device and/orthe source of the media transmitted to the Bluetooth device. For thelocation event stream 612, historical monitor 110 can convert rawlocation data (e.g., grid coordinates, GNSS data, cell toweridentification data, Wi-Fi network identifiers, etc.) into locationterms that a human user can understand (e.g., home, work, school,grocery store, restaurant name, etc.).

In some embodiments, historical monitor 110 can generate or obtain moreaccurate location information than context monitor 108. For example,context monitor 108 can provide current (e.g., instantaneous) locationinformation without much, if any, processing. This initial location datacan be inaccurate due to a variety of issues with location technologies(e.g., signal multipath issues, difficulty connecting to enoughsatellites, etc.). Given additional time and additional data, thelocation can be determined with greater accuracy. Since, historicalmonitor 110 processes historical data (rather than current orinstantaneous data), historical monitor 110 can take the time to obtainmore accurate location information from location API 132, for example.This additional metadata describing an event can be stored in the eventstream records of history database 600.

In some embodiments, historical monitor 110 can obtain historicalinformation about a context item upon initialization of monitor bundle106. For example, if monitor bundle 106 is configured to monitorlocation context, then context daemon 102 can load, invoke, and/orinitialize monitor bundle 106 as needed, as described above. Whenmonitor bundle 106 is initialized, context monitor 108 can collectcontext information for the location context item. However, when monitorbundle 106 is initialized, there is no historical data for the locationcontext item because the location context item was not previouslymonitored. Thus, in some embodiments, historical monitor 110 can requestlocation history data from location API 132 and generate historicalcontext information (e.g., event streams, event stream objects, etc.)based on the location history data received from location API 132.

Event Stream Privacy

In some embodiments, each event stream can have a corresponding privacypolicy 122. In some embodiments, the event streams can be configuredwith default privacy policies. In some embodiments, an administrativeuser can provide input to the computing device to configure the privacypolicies for each event stream (e.g., for each context item). Forexample, the privacy policy corresponding to respective event streamscan change over time.

In some embodiments, the event stream for a context item can have aprivacy policy that prevents maintaining historical information for thecontext item. For example, an event stream corresponding to the locationcontext item can have a policy that disables maintaining a historicalrecord of the location of the computing device. When this “no history”policy is configured for an event stream, historical monitor 110 willnot generate historical context information (e.g., event stream objects)for the event stream.

In some embodiments, the event stream for a context item can have aprivacy policy that specifies an amount of time (e.g., time-to-live)that historical context information should be stored before beingdeleted. For example, an event stream corresponding to the “app infocus” context item can have a time-to-live policy specifying that eventstream data for the “app in focus” context item that is older than aspecified amount of time (e.g., 3 days, 1 month, etc.) should bedeleted. Context daemon 102 can periodically perform maintenance on theevent stream to delete event stream objects that are older than theamount of time specified in the time-to-live policy.

In some embodiments, the event stream for a context item can have atimestamp de-resolution policy. For example, when the timestampde-resolution policy is in effect, historical monitor 110 can make theprecise timestamps associated with events (e.g., state changes) in theevent stream less precise. For example, a location change event can havea timestamp that is accurate down to the millisecond. When thede-resolution policy is applied to the event stream, historical monitor110 can use a less accurate timestamp that is accurate down to thesecond or minute. For example, by using a less accurate timestamp for alocation event stream, the system can protect a user's privacy bypreventing context clients from determining the precise timing of auser's locations (e.g., movements).

In some embodiments, the event stream for a context item can have astorage location policy. For example, the computing device can beconfigured with different storage locations corresponding to thesecurity state of the computing device. For example, the computingdevice can have an “A” class database that can only be accessed when thecomputing device is unlocked (e.g., the user has entered a passcode tounlock the device). The computing device can have a “C” class databasethat can be accessed after the first unlock (e.g., without requiring asubsequent unlock) after a reboot or startup of the computing device.The computing device can have a “D” class database that can be accessedanytime (e.g., regardless of passcode entry). The storage locationprivacy policy for the event stream can identify in which class ofdatabase to store the corresponding event stream data.

Efficient Context Monitoring

In some embodiments, the computing device can be configured to terminatesoftware running on the computing device when the software is not beingused. For example, the operating system of the computing device can beconfigured to identify processes that are idle. The operating system canshutdown (e.g., terminate, kill) idle processes to free up memory orconserve battery resources for use by other components (e.g., software,hardware) of the system. However, if the operating system terminates anidle context daemon 102, context daemon 102 will no longer be able tomonitor the current context of the system and will not be able to notifyrequesting clients 126 of context changes. Similarly, if the operatingsystem terminates an idle requesting client 126, requesting client 126will not be running to receive the callback notification from contextdaemon 102. The following paragraphs describe various mechanisms bywhich context daemon 102 and/or requesting client 126 can be restartedto handle context monitoring and/or callback operations.

FIG. 7 is a block diagram of an example system 700 for providing acontext callback notification to a requesting client 126. For example,system 700 can correspond to system 100 of FIG. 1 above. In someembodiments, system 700 can include launch daemon 702. For example,launch daemon 702 can be configured to launch (e.g., invoke, start,execute, initialize, etc.) applications, utilities, tools, and/or otherprocesses on the computing device. Launch daemon 702 can be configuredto monitor processes and terminate idle processes on the computingdevice.

In some embodiments, launch daemon 702 can launch requesting client 126.For example, a process (e.g., operating system, user application, etc.)running on the computing device can invoke requesting client 126. Launchdaemon 702 can receive a message corresponding to the invocation and canlaunch requesting client 126. Upon launching requesting client 126,launch daemon 702 can provide requesting client 126 a client identifier704 that can be used to identify requesting client 126 within thecomputing device.

In some embodiments, client identifier 704 can be token (e.g., encrypteddata) generated by launch daemon 702 and assigned to requesting client126 by launch daemon 702. Launch daemon 702 can store a mapping betweenthe token and the software package corresponding to (e.g., defining)requesting client 126 in client identifier database 706. The token canbe generated such that the token itself does not identify thecorresponding requesting client 126. However, when launch daemon 702later receives the token, launch daemon 702 can use the token to look upthe corresponding requesting client 126 in client identifier database706. Thus, the token can be used by launch daemon 702 as an index toidentify the corresponding requesting client while the token is opaqueto other software within the computing device.

In some embodiments, client identifier 704 can be an instance identifiercorresponding to a specific instance of requesting client 126. In someembodiments, client identifier 704 can identify a software package(e.g., application, utility, tool, etc.) across all instances ofrequesting client 126. For example, when launch daemon 702 launches afirst instance of requesting client 126, client identifier 704 canidentify the first instance of requesting client 126. When requestingclient 126 is terminated (e.g., because requesting client 126 has becomeidle), the same client identifier 704 can be used to identify subsequentinstances of requesting client 126 that are launched by launch daemon702. Launch daemon 702 can launch context daemon 102 using similarmechanisms as requesting client 126.

In some embodiments, requesting client 126 can send callback request 708to context daemon 102. For example, callback request 708 can includeclient identifier 704 and a callback predicate, as described above. Uponreceipt of callback request 708, context daemon 102 can store clientidentifier 704 and the predicate in predicate database 116, as describedabove.

In some embodiments, when requesting client 126 sends the callbackrequest 708 to context daemon 102, requesting client 126 establishes acommunication session 709 with context daemon 102. In some embodiments,system 700 can be configured such that the communication session betweenrequesting client 126 and context daemon 102 can only be initiated byrequesting client 126. For example, context daemon 102 can be configuredto not be able to directly establish a communication session withrequesting client 126. Thus, in some embodiments, context daemon 102 canonly communicate with (e.g., send a callback notification to) requestingclient 126 while communication session 709 established by requestingclient 126 is still open.

In some embodiments, context daemon 102 can collect contextualinformation about events occurring on the computing device. For example,context daemon 102 can collect context information from monitor bundles106 and reporting client 124, as described above. In some embodiments,context daemon 102 can store the current context in context database712. For example, context daemon 102 can store the current context incontext database 712 to facilitate restoration of context information tocontext daemon 102. When context daemon 102 is terminated and restarted,context daemon 102 can restore the current context (e.g., previouslystored context) from context database 712 while context daemon 102 iswaiting for a context update from monitor bundles 106.

In some embodiments, context daemon 102 can determine whether thecurrent context corresponds to a predicate received from requestingclient 126. For example, when new context data is obtained that updatesthe current context (e.g., changes the state of a context item), contextdaemon 102 can compare the callback predicates stored by context daemon102 in callback registry 114 or predicate database 116 with the contextitems in current context 112 to determine whether the current contextmatches (corresponds to) the conditions specified by the predicates.When the current context matches a predicate registered by requestingclient 126, context daemon 102 can send notification 710 to requestingclient 126. For example, notification 710 can identify the callbackrequest previously sent by requesting client 126 to context daemon 102,as described above. Thus, context daemon 102 can notify (e.g., callback) requesting client 126 when context daemon 102 detects a currentcontext in which requesting client 126 is interested.

FIG. 8A and FIG. 8B are block diagrams of example system 700illustrating restarting a requesting client that has been terminated.For example, in FIG. 8A, system 700 has determined that requestingclient 126 is idle and has terminated requesting client 126 (e.g.,dashed outline of requesting client 126 indicating termination). In FIG.8A, context daemon 102 is still running. However, because requestingclient 126 has been terminated, communication session 709 has also beenterminated.

FIG. 8B is a block diagram illustrating an example mechanism forrestarting requesting client 126 using system 700. Continuing theexample of FIG. 8A, context daemon 102 can receive context informationthat matches a callback predicate registered by requesting client 126.In response to determining that the context information matches thecallback predicate, context daemon 102 can attempt to notify requestingclient 126. While attempting to notify requesting client 126, contextdaemon 102 can determine that communication session 709 between contextdaemon 102 and requesting client 126 has been terminated. In response todetermining that communication session 709 is terminated, context daemon102 can request that launch daemon 702 restart requesting client 126.For example, context daemon 102 can send client identifier 704 receivedfrom requesting client 126 to launch daemon 702 in a request to restartrequesting client 126.

In some embodiments, upon receipt of client identifier 704, launchdaemon 702 can launch requesting client 126. For example, launch daemon702 can determine that context daemon 102 is authorized to request thatrequesting client 126 be restarted based on the client identifierprovided by context daemon 102. For example, context daemon 102 wouldnot have client identifier 704 (e.g., token) if requesting client 126did not previously request a callback from context daemon 102 andprovide client identifier 704 to context daemon 102.

In some embodiments, upon restarting, requesting client 126 can sendcallback request 708 to context daemon 102. For example, requestingclient 126 can establish a new communication session 802 betweenrequesting client 126 and context daemon 102 by sending callback request708 to context daemon 102. Once communication session 802 isestablished, context daemon 102 can send notification 710 to requestingclient 126 to notify requesting client 126 that the callback predicateprovided by requesting client 126 has been satisfied by the currentcontext.

FIG. 9A and FIG. 9B are block diagrams of example system 700illustrating restarting a context daemon that has been terminated. Forexample, in FIG. 9A, system 700 has determined that context daemon 102is idle and has terminated context daemon 102 (e.g., dashed outline ofcontext daemon 102 indicating termination). In FIG. 9A, requestingclient 126 is still running. However, because context daemon 102 hasbeen terminated, communication session 709 has also been terminated.

FIG. 9B is a block diagram illustrating an example mechanism forrestarting context daemon 102 using system 700. Continuing the exampleof FIG. 9A, system 700 can restart context daemon 102 in response toreceiving a message from requesting client 126 that is directed tocontext daemon 102.

In some embodiments, requesting client 126 can detect that communicationsession 709 between requesting client 126 and context daemon 102 hasterminated. In response to detecting that communication session 709 hasterminated, requesting client 126 can reestablish the communicationsession by sending a message to the terminated context daemon 102. Insome embodiments, requesting client can send the message to contextdaemon 102 using messaging system 902. Messaging system 902 of system700 can determine that context daemon 102 is not running and send amessage to launch daemon 702 to cause launch daemon 702 to restartcontext daemon 102. In response to receiving the message, launch daemon702 can restart context daemon 102. Once context daemon 102 is running,messaging system 902 can send the message from requesting client 126 tocontext daemon 102, thereby reestablishing the communication channelbetween requesting client 126 and context daemon 102.

In some embodiments, upon restarting, context daemon 102 can restore itscallback registry 114 and current context 112. For example, callbackregistry 114 can be restored from predicate database 116. Currentcontext 112 can be restored from context database 712. Upon restarting,context daemon 102 can load the monitor bundles 106 necessary forcollecting context information to service the callback requests restoredfrom predicate database 116. Context daemon 102 can update currentcontext 112 with the context information reported by loaded monitorbundles 104 and notify requesting client 126 when the context items incurrent context 112 match a predicate registered by requesting client126, as described above.

FIG. 10A and FIG. 10B are block diagrams of example system 700illustrating restarting a context daemon and a requesting client thathave been terminated. For example, in FIG. 10A, system 700 hasdetermined that both context daemon 102 and requesting client 126 areidle and has terminated context daemon 102 and requesting client 126(e.g., dashed outline indicating termination). In FIG. 10A, because bothcontext daemon 102 and requesting client 126 are terminated,communication session 709 is terminated.

FIG. 10B is a block diagram illustrating an example mechanism forrestarting context daemon 102 and requesting client 126 using system700. Continuing the example of FIG. 10A, system 700 can restart contextdaemon 102 in response to receiving a message from intervening client1002 that is directed to terminated context daemon 102. For example,similar to requesting client 126 in FIG. 9B, intervening client 1002 cansend a message to the now terminated context daemon 102. Messagingsystem 902 can receive the message and determine that context daemon 102is not running. In response to determining that context daemon 102 isnot running, messaging system 902 can send a message to launch daemon702 to cause launch daemon 702 to restart context daemon 102.

In some embodiments, upon restarting, context daemon 102 can restore itscallback registry 114 from predicate database 116. Upon restarting,context daemon 102 can restore its current context 112 from contextdatabase 712 and can start collecting updated context information, asdescribed above. When context daemon 102 determines that a registeredpredicate matches the current context information, context daemon 102can attempt to notify requesting client 126. When context daemon 102determines that a communication session 709 does not exist betweenrequesting client 126 and context daemon 102, context daemon 102 canrequest that launch daemon 702 restart requesting client 126 so that thecommunication session can be reestablished and context daemon 102 cancallback requesting client 126, as described above with reference toFIG. 8B.

FIG. 11 is a block diagram of an example system 1100 configured torestart requesting client 126 and/or context daemon 102 based on devicestate information received by launch daemon 702. For example, system1100 can correspond to system 700 and can perform similar functions assystem 700, as described above.

In some embodiments, launch daemon 702 can be configured to receivedevice state 1104. For example, device state 1104 can be low-levelconcrete state data generated by various hardware and/or softwarecomponents of the computing device. For example, launch daemon 702 canreceive device state 1104 that includes location data generated by alocation services component (e.g., GPS receiver, Wi-Fi or cellular datacomponent, etc.) of the computing device. The received locationinformation can be raw location state data (e.g., GPS coordinates). Theraw location state data can be translated into high-level locationinformation (e.g., home, work, etc.). Changes in the raw location datacan happen more frequently than changes in the high-level locationinformation (e.g., multiple GPS coordinates can be within the samehigh-level location information). In some embodiments, device state 1104can indicate a change in location but can be configured to not providehigh-level location information (e.g., human-readable labels).

For example, requesting client 126 can send callback request 708 tocontext daemon 102 that has a location-based predicate. The predicatecan specify that the requesting client 126 should be notified when thecurrent location (e.g., current context) of the computing device is theuser's home (e.g., location==home). To determine that the devicelocation is the user's home, context daemon 102 and/or monitor bundle106 can collect information from location API 132 and a contactsapplication running on the user's device that defines where “home” islocated (e.g., that defines the geographic location associated with the“home” label). The location information from location API 132 can be rawlocation state data. Context daemon 102 can analyze and translate theraw location state data received from location API 132 into high-levellocation information (e.g., home, work, etc.). Context daemon 102 canregister the raw location state data and changes in the raw locationstate data. The changes in raw location state data can be more frequentthan changes in high-level information (e.g., multiple GPS coordinatescan be within the same high-level location information). Context daemon102 can determine when the context item “location” is equal to “home”(e.g., high-level location information) by comparing the raw locationstate data determined from location API 132 to the definition of “home”in the contacts application. For example, the raw location state datafrom location API 132 can be analyzed by context daemon 102. Contextdaemon 102 can determine from the raw location state data, thehigh-level location information of the requesting client 126 and when achange in the raw location state data is sufficient to reflect a changein the high-level location information of requesting client 126 (e.g.,change from at home to not at home or vise versa). When the change inthe raw location state data is sufficient, the predicate can be analyzedto determine if the requesting client should be notified (e.g., “home”or “not home”). When a change of location is not sufficient, therequesting client 126 is not notified preserving CPU cycles and memoryuntil a future location change is sufficient to change the location. Asdemonstrated with this example, determining that the location predicatedefined by requesting client 126 (e.g., “home”) is satisfied depends oncombining both current geographic location data (e.g., grid coordinates)with user data that correlates a label (e.g., “home”) with a geographiclocation. Thus, the abstract location context “home” can be determinedby analyzing concrete state data generated by the computing device'slocation services and contacts application. The abstract locationcontext “home” (or any other abstract location, e.g., work, gym, etc.)can be set by the user and can be changed by the user or be updated overtime.

In some embodiments, when context daemon 102 receives callback request708 from requesting client 126, context daemon 102 can send device staterequest 1102 to launch daemon 702 to register interest in state changesof specific components of the computing device. When device state 1104is received by launch daemon 702, launch daemon 702 can determine thatthere has been state change with respect to the specified components andnotify context daemon 102 and/or requesting client 126.

In some embodiments, device state request 1102 can specify that launchdaemon 702 should notify context daemon 102 when the specified statechanges occur. For example, when requesting client 126 sends a callbackrequest to context daemon 102 that specifies a location-based callbackpredicate, context daemon 102 can send device state request 1102 tolaunch daemon 702 requesting that launch daemon 702 notify contextdaemon 102 when a location component state change is detected by launchdaemon 702.

In some embodiments, device state request 1102 can specify that launchdaemon 702 should notify requesting client 126 when the specified statechanges occur. For example, when requesting client 126 sends a callbackrequest to context daemon 102 that specifies a location-based callbackpredicate, context daemon 102 can send device state request 1102 tolaunch daemon 702 requesting that launch daemon 702 notify requestingclient 126 when a location component state change is detected by launchdaemon 702. In some embodiments, device state request 1102 can includeclient identifier 704 corresponding to requesting client 126 so thatlaunch daemon 702 can determine which requesting client 126 to notify.

FIG. 12A and FIG. 12B are block diagrams of an example system 1100illustrating restarting a context daemon using a launch daemon. Forexample, in FIG. 12A, system 1100 has determined that both contextdaemon 102 and requesting client 126 are idle and has terminated contextdaemon 102 and requesting client 126 (e.g., dashed outline indicatingtermination). In FIG. 12A, because both context daemon 102 andrequesting client 126 are terminated, communication session 709 is alsoterminated.

FIG. 12B is a block diagram illustrating an example mechanism forrestarting context daemon 102 using launch daemon 702 of system 1100. Asdescribed above with reference to FIG. 11, context daemon 102 canreceive a callback request from requesting client 126 that specifies acontext predicate for sending notification 710 from context daemon 102to requesting client 126. In response to receiving the predicate,context daemon 102 can send device state request 1102 to launch daemon702 to register interest in device state changes associated with thepredicate. For example, if requesting client 126 specifies alocation-based callback predicate, context daemon 102 can ask launchdaemon 702 to notify context daemon 102 when the location of thecomputing device changes. When launch daemon 702 receives device state1104 that indicates a change in location, launch daemon 702 can attemptto notify context daemon 102. Continuing the example of FIG. 12A, sincecontext daemon 102 is not running on the computing device, launch daemon702 can determine that context daemon 102 is not running and launch(e.g., restart, initiate, invoke, execute, etc.) context daemon 102.Once context daemon 102 is restarted, context daemon 102 can requestthat launch daemon 702 restart requesting client 126, as described abovewith reference to FIG. 8B.

FIG. 13A and FIG. 13B are block diagrams of example system 1100illustrating restarting a requesting client 126 using the launch daemon.For example, in FIG. 13A, system 1100 has determined that both contextdaemon 102 and requesting client 126 are idle and has terminated contextdaemon 102 and requesting client 126 (e.g., dashed outline indicatingtermination). In FIG. 13A, because both context daemon 102 andrequesting client 126 are terminated, communication session 709 is alsoterminated.

FIG. 13B is a block diagram illustrating an example mechanism forrestarting requesting client 126 using launch daemon 702 of system 1100.As described above with reference to FIG. 11, context daemon 102 canreceive a callback request from requesting client 126 that specifies acontext predicate for sending callback notification 710 from contextdaemon 102 to requesting client 126. In response to receiving thepredicate, context daemon 102 can send device state request 1102 tolaunch daemon 702 to register interest in device state changesassociated with the predicate on behalf of requesting client 126. Forexample, context daemon 102 can provide client identifier 704 to launchdaemon 702 when registering interest in device state changes associatedwith the predicate. For example, if requesting client 126 specifies alocation-based callback predicate, context daemon 102 can ask launchdaemon 702 to notify requesting client 126 when the location of thecomputing device changes. When launch daemon 702 receives device state1104 that indicates a change in location, launch daemon 702 can attemptto notify requesting client 126 (e.g., identified by client identifier704). Continuing from FIG. 13A, since requesting client 126 is notrunning on the computing device, launch daemon 702 can determine thatrequesting client 126 is not running and launch (e.g., restart,initiate, invoke, execute, etc.) requesting client 126. Once requestingclient 126 is restarted, requesting client 126 can cause launch daemon702 to restart context daemon 102 by sending a message to context daemon102, as described above with reference to FIG. 9B.

Predicting Future Events

In some embodiments, context daemon 102 can predict future events basedon event stream information. For example, context daemon 102 can analyzehistorical context information (e.g., event streams, event streamobjects, etc.) to determine historical user behavior patterns. Contextdaemon 102 can predict future user behavior based on these past behaviorpatterns. For example, predicable user behavior can include sleeppatterns, working patterns, exercise patterns, eating patterns, andother repeating user behaviors. Context daemon 102 can determine whenthese user behaviors occur based on clues in the event streams thatreflect how a user interacts with the computing device during these useractivities.

For ease of explanation, the description that follows will describe anexample sleep prediction embodiment based on historical device lockedstate event stream data. However, the mechanisms used for sleepprediction can be used to predict other user behaviors as well byanalyzing other event stream data. For example, context daemon 102 canuse location data to infer user working patterns. Context daemon 102 canuse accelerometer data to infer user exercise patterns. Context daemon102 can use application data (e.g., checking in at a restaurant on asocial media software application) to infer user eating patterns.

In some embodiments, context daemon 102 can use device lock state eventstream data to determine and/or predict user sleep patterns. Forexample, if the computing device (e.g., handheld device, smartphone,etc.) remains locked for a long period of time (e.g., 5 hours or more),then context daemon 102 can infer that the user is sleeping. In someembodiments, other event stream information (e.g., accelerometer data,application usage data, etc.) can be used to confirm the sleep patternsand/or the sleep prediction. In some embodiments, context daemon 102 canperform sleep prediction for the current day at some time after the userwakes up from the previous day's sleep and before the next predictedsleep period. For example, context daemon 102 can perform thecalculations to predict the next sleep period upon detecting that theuser has awakened from the current sleep period. For example, contextdaemon 102 can detect that the user is awake by determining that thecurrent value for the “locked” context item is false (e.g., the user hasunlocked the device) and that the current time is after the predictedsleep period ends.

Slot-Wise Prediction of Future Events

In some embodiments, context daemon 102 can perform slot-wise averagingto predict future events. For example, to predict (e.g., determine,calculate, etc.) user sleep patterns, context daemon 102 can analyze thelocked state event stream described above. Context daemon 102 cananalyze the locked state event stream by dividing the locked state eventstream into consecutive 24-hour periods over the previous 28 days.Context daemon 102 can divide each 24-hour period into 96 15-minuteslots. Context daemon 102 can determine the locked state for each15-minute block in each 24-hour period. For example, if the computingdevice remained locked for the entire 15-minute slot, then the lockedstate for the slot can be true (e.g., 1). If the computing device wasunlocked during the 15-minute slot, then the locked state for the slotcan be false (e.g., 0). The locked state data for the 15-minute slotswithin each 24-hour period can be combined to generate 28 data vectorsrepresenting each of the previous 28 days. For example, each vector(e.g., having a length of 96) can include 96 locked state valuescorresponding to each of the 15-minute slots within a day. Contextdaemon 102 can then average each 15-minute slot over the 28-day periodto determine the historical sleep pattern of the user.

FIG. 14 is a graph 1400 that illustrates an example of slot-wiseaveraging to predict future events. For example, graph 1400 illustratesusing device locked state to determine sleep patterns and predict futuresleep periods. For example, each horizontal line represents a lockedstate data vector for a 24-hour period. The 24-hour period can rangefrom t-n to t+n, where ‘t’ is some time corresponding to approximatelythe (e.g., presumed, typical, calculated, etc.) middle of the user'ssleep cycle and ‘n’ can be 12. For example, if the typical person sleepsfrom 10 pm to 6 am, then the ‘t’ can be 2 am. In graph 1400, ‘C’represents the current day. Thus, C-1 is yesterday, C-2 is two days ago,C-7 is one week ago, and C-28 is four weeks ago. Each day has 96corresponding 15-minute slots. For example, graph 1400 depicts the15-minutes slots corresponding to 3:30-3:45 am, 5:00-5:15 am, and6:15-6:30 am. While only three 15-minute slots are shown on graph 1400for clarity, each vector has 96 15-minute slots and the operationsdescribed with reference to the three 15-minute slots on graph 1400 willbe performed on each of the 96 slots in each 24-hour period.

With reference to vector C-1 on graph 1400, the value of one (e.g., 1,true) in the 3:30 slot and the 5:00 slot indicates that the computingdevice remained locked during the entire corresponding 15-minute slot.The value of zero (e.g., 0, false) during the 6:15 slot indicates thatthe computing device was unlocked sometime during the 15-minute period.For example, context daemon 102 can infer that the user must have beenawake to unlock the computing device in the 6:15 slot. Context daemon102 can infer that the user was asleep when the device remains lockedfor a threshold period of time (e.g., 5 hours), as described furtherbelow.

To determine the probability that the user will keep the computingdevice locked during each 15-minute slot (and therefore remained asleep)in the current day, context daemon 102 can average the values of each15-minute slot over the previous 28 days to predict values for each15-minute slot in the current 24-hour period. Context daemon 102 can usethe average 15-minute slot values calculated for the current 24-hourperiod to identify a period of time in the current 24-hour period thatexceeds a sleep threshold (e.g., 5 hours) where the device is likely toremain locked. For example, where the average value for a 15-minute slotis above some threshold value (e.g., 0.5, 50%, etc.), then contextdaemon 102 can determine that the computing device will remain lockedwithin that 15-minute slot. Context daemon 102 can determine acontiguous (or mostly contiguous) series of 15-minute slots havingvalues greater than the threshold value that, when combined, exceeds thesleep threshold period of time. Once the series of 15-minute slots isdetermined, context daemon 102 can identify the period of time coveredby the series of 15-minute slots as the predicted sleep period.

In some embodiments, context daemon 102 can perform weighted averagingacross locked state data vectors. For example, each vector can beweighted such that older locked state data is less influential on theaverage than newer locked state data. In some embodiments, contextdaemon 102 can perform short term averaging over a series of recent days(e.g., over each of the last 7 days) and/or long term averaging over aseries of weeks (e.g., 7 days ago, 14 days ago, 21 days ago, 28 daysago). For example, short term averaging may be better for predictingdaily patterns, while long term averaging may be better for predictingwhat the user does on a particular day of the week. For example, iftoday is Saturday, the user's activities on the previous Saturday may bea better predictor of the user's behavior today than the user'sactivities yesterday (e.g., on Friday), especially if the user worksMonday-Friday.

Short-Term Averaging

In some embodiments, the following short-term weighting averagingalgorithm can be used by context daemon 102 to determine the probability(P_(S)) that the device will remain locked within a 15-minute slot:

$P_{S} = \frac{\left( {{\lambda_{S}V_{1}} + {\lambda_{S}^{2}V_{2}\mspace{14mu} \ldots} + {\lambda_{S}^{7}V_{7}}} \right)}{\left( {\lambda_{S} + {\lambda_{S}^{2}\mspace{14mu} \ldots} + \lambda_{S}^{7}} \right)}$

, where V_(i) corresponds to C-1, V₂ corresponds to C-2, etc., and V₇corresponds to C-7, and λ is an experimentally determined weight havinga value between zero and one. For example, the short term weightingalgorithm can be used to calculate a weighted average of each 15-minuteover the previous seven days.

Long-Term Averaging

In some embodiments, the following long-term weighted averagingalgorithm can be used by context daemon 102 to determine the probability(P_(L)) that the device will remain locked within a 15-minute slot:

$P_{L} = \frac{\left( {{\lambda_{L}V_{7}} + {\lambda_{L}^{2}V_{14}} + {\lambda_{L}^{3}V_{21}} + {\lambda_{L}^{4}V_{28}}} \right)}{\left( {\lambda_{L} + \lambda_{L}^{2} + \lambda_{L}^{3} + \lambda_{L}^{4}} \right)}$

, where V₇ corresponds to C-7, V₁₄ corresponds to C-14, V₂₁ correspondsto C-21, and V₂₈ corresponds to C-28, and ‘λ’ is an experimentallydetermined weight having a value between zero and one. For example, thelong-term weighting algorithm can be used to calculate a weightedaverage of each 15-minute for the same day of the week over the lastfour weeks.

In some embodiments, the short-term weighed averaging algorithm and thelong-term weighted averaging algorithm can be combined to generate acombined (e.g., composite, overall, etc.) probability (P) that a15-minute slot will remain locked within a 15-minute slot as follows:

$P = \frac{P_{S} + {rP}_{L}}{1 + r}$

, where ‘r’ is an experimentally determined number (e.g., 0.5) that canbe used to tune the influence that the long-term weighted average has onthe probability calculation.

Proportional Slot Values

FIG. 15 depicts example graphs 1500 and 1550 illustrating calculatingproportional slot values. For example, rather than assigning true (1)and false (0) values for each 15-minute slot within a 24-hour periodC-n, as in the description above, context daemon 102 can determineduring how much of each 15-minute slot the computing device was locked,or unlocked, and assign a proportional value to the slot representingthe proportionate amount of time within the slot during which the devicewas locked.

Referring to graph 1500, the shaded region of each 15-minute timeslotcan represent the time within the timeslot during which the device waslocked. For example, the device was locked during the entirety of both3:30-3:45 am and 5:00-5:15 am timeslots. Thus, the 3:30 and 5:00timeslots can be assigned a value of one (1). However, the computingdevice was locked for only a portion of the 6:15-6:30 am timeslot. Ifthe computing device was locked for the first 10 minutes of the 6:15timeslot, then the 6:15 timeslot can be assigned a value of 10/15 or0.67 representing the proportionate amount of the 15-minute slot duringwhich the device was locked, as illustrated by graph 1550. If thecomputing device was locked and unlocked repeatedly (e.g., locked for 5minutes, unlocked for 2 minutes, locked for 1 minute, unlocked for 5minutes, etc.), the computing device can add up the locked time periods,add up the unlocked time periods, and calculate the proportion of the15-minute slot during which the computing device was locked. In someembodiments, a proportional value can be determined for each 15-minutetimeslot within a 24-hour period (e.g., data vector). In someembodiments, the proportional value for each 15-minute timeslot can beused when calculating the short-term and/or long-term probabilitiesdescribed above.

Generating a Sleep Curve

FIG. 16A is a series of graphs 1600 illustrating an example method forpresenting measured data representing a context, such as a sleep state,over a period of days. FIG. 16B is a cumulative graph 1625 derived fromdata in graphs 1600 illustrating an example method for predicting afuture context over a period of days. For example, the methodillustrated by graphs 1600, 1625 can be used to predict a future sleepperiod for a user of the computing device. For example, each column(e.g., column 1602, column 1604) in graphs 1600, 1625 can represent a15-minute timeslot, as described above. The value of each 15-minutetimeslot can be represented by the height of the column, and representsa measurement (graphs 1600) or probability (graph 1625) of whether thecomputing device is in a sleep state or not. In graph 1600, the heightcan correspond to a binary value. For example, the probability (P) canrange from zero (e.g., 0, 0%) to one (e.g., 1, 100%). A probability of“1” means that it was observed that the device was locked for that 15minute period and a probability of “0” means that it was observed thatthe device was unlocked in that 15 minute period. In graph 1625 theheight can correspond to the combined weighted average probability (P)for the timeslot as described above. The probability can represent, forexample, the probability that the computing device will remain lockedduring the 15-minute slot, as described above. In some embodiments, theprobability can be calculated from the binary (e.g., 0, 1) 15-minutetimeslot values. In some embodiments, the probability can be calculatedfrom proportional 15-minute timeslot values (as shown in FIG. 15). Whilethe heights of the columns in FIG. 16A (and curves in FIG. 16C) appearto extend beyond the threshold (0%, 100%, etc.), this is just forclarity of illustration.

As shown in FIG. 16A, the measurements for the timeslots can be takeneach day for a period of days (e.g., 7 days, 14, days, 21 days, 28 days,etc.). After Day 1, a first graph is determined for each timeslot. AfterDay 2, a cumulative graph (e.g., as shown in FIG. 16B) is determined bycombining (e.g., average, median, etc.) the first graph and a secondgraph from Day 2. The graphs can be combined by timeslot (i.e., thefirst 15-minute timeslot from the first graph is combined with the first15-minute timeslot from the second graph, and so on.). After Day 3, thecumulative graph can be altered to include a third graph from Day 3 bycombining the cumulative graph and the third graph. This process cancontinue for the determined period of days (e.g., 28 days) and canmaintain data for the most current period (e.g., last 28 days).

In some embodiments, context daemon 102 can determine the sleep cycle ofa user of the computing device. For example, context daemon 102 candetermine a sleep probability threshold value 1606 for determining which15-minute slots correspond to the user's sleep period. In someembodiments, the sleep probability threshold value 1606 can bedynamically determined. For example, given a minimum sleep period (e.g.,5 hours, 7 hours, etc.), context daemon 102 can determine a value (e.g.,0.65, 50%, etc.) for sleep probability threshold 1606 that results in ablock of contiguous 15-minute slots that is at least as long as theminimum sleep period and that includes 15-minute slots having (e.g.,probability, average) values that exceed sleep probability threshold1606. Stated differently, context daemon 102 can adjust sleepprobability threshold 1606 up and down until a series of 15-minute slotsthat when combined meet or exceed the minimum sleep period and havevalues above the sleep probability threshold. The threshold value 1606can also be defined based on the application (e.g., sleep prediction,exercise prediction, etc.). In some embodiments, the threshold value1606 can be user-defined.

In some embodiments, once sleep probability threshold 1606 isdetermined, context daemon 102 can determine the user's sleep period(e.g., 1608, 1610). Sleep period I 1608 can be based on non-contiguous15-minute timeslots (e.g., including an outlier 1612, as discussedbelow). Sleep period II 1610 can be based on the contiguous 15-minuteslots. For example, sleep period 1610 can correspond to the time periodcovered by the contiguous 15-minute timeslots above threshold 1606(e.g., not including column 1612). Referring to FIG. 16B, sleep period I1608 can correspond to the time period beginning at 11 pm and ending at7 am and sleep period II 1610 can correspond to the time period being at11 PM and ending at 5 am. Sleep period I 1608 is based on the assumptionthat if the user is considered asleep for all periods except one or twoshort periods between 11 pm and 7 am, that the sleep period should beconsidered the whole period. While Sleep period II 1610 is based on theassumption that sleep should be defined as a period of continuous sleep.Both periods can also include the assumption that the sleep should be inthe same location, and that there is only one sleep period per 24 hours.

FIG. 16C is a series of graphs 1650 illustrating another example methodfor representing a measured context, such as sleep periods, to be usedfor predicting future contexts over a period of days. FIG. 16D is acumulative graph 1675 illustrating another example method fordetermining a probability curve for predicting future contexts based onthe measured data over the period of days. As shown in FIG. 16C, a sleepcurve can be created based on the measured raw data of each timeslot(while the timeslots are not individually shown in FIG. 16C, the datacollection is similar to that shown in FIG. 16A with recorded periods ofobserved locked or unlocked states) over a predetermined period (e.g., 7days, 14 days, 21 days, 28 days, etc.). The sleep curves in FIG. 16C,are generated using a unimodal curve, wherein a single rise in the curverepresents the sleep period. The sleep period represents the singlelongest contiguous period where the device is in an unlocked state(timeslots as binary high (e.g., 1, 100%)), and not changing locations.In some embodiments, the sleep period may also be limited to commonsleeping hours. While the sleep-side and wake-side curves appear to havedifferent heights, this is just for clarity of illustration; both sidesof the curve actually have the same height.

To predict the user's sleep cycle (e.g., assuming a user has one sleepcycle per 24-hour period), it can be useful to generate a cumulativeprobability curve 1682, 1684 (e.g., a unimodal curve) over a period ofdays that monotonically increases (e.g., increasing probability that thedevice will remain locked) as the user is entering a sleep cycle andmonotonically decreases (e.g., decreasing probability that the devicewill remain locked) as the user is exiting the sleep cycle. Whilecumulative probability curve 682, 1684 appear to show a time period for11 pm to 7 am, this is just for clarity of illustration; the cumulativeprobability curves extend for a 24-hour period.

In some embodiments, the cumulative probability curve can be calculatedbased on combining the collection of sleep-side and wake-side curves forevery day in the period for which there is data. For example, after Day1, a first sleep-side and wake-side curves are determined for the sleepperiod. After Day 2, a cumulative graph of the first sleep-side andwake-side curves from Day 1 are combined (e.g., average, median, etc.)with second sleep-side and wake-side curves from Day 2. After Day 3, thecumulative graph can be altered to include the curves from Day 3 and soon. This process can continue for the determined period of days (e.g.,28 days) and can maintain data for the most current period (e.g., last28 days).

FIG. 16D illustrates two different possible representations of thecumulative sleep-side and wake-side curves. One representation is asmooth curve that is a best fit of the sleep-side and wake-side curve.The other representation is a step curve, which more accurate reflectsthe combination of the data. Again the representative of the sleep-sidecurves are show in solid lines and the representation of the wake-sidecurves are shown in dotted lines.

As addressed above, the individual sleep-side and wake-side curves canbe converted into a cumulative probability curve (e.g., sleep-side 1682,wake-side 1684) by taking the average of the sleep-side and wake-sidecurves as described above. Once the cumulative probability curve hasbeen calculated, a sleep period 1680 (including a predicted start sleeptime and predicted stop steep time) can be determined. The cumulativesleep curve can represent a contiguous portion of the sleep-side 1652and wake-side 1654 step functions over a period of time. When cumulativeprobability curve 1682, 1684 is greater than (i.e., above) the thresholdvalue 1686 for the largest contiguous period (e.g., sleep period 1680)the user is predicted as sleeping, or more accurately, the computingdevice is predicted to be in and remain in a locked or sleep state. Whencumulative probability curve 1682, 1684 is less than (i.e., below) thethreshold value 1686 the user is predicted as awake, or more accurately,the computing device is predicted to be potentially unlocked or in useat some point during this period. In some embodiments, a start sleeptime can be predicted based on the intersection of the sleep-side 1682of the cumulative probability curve and threshold 1686 (e.g., 11 PM, asillustrated in FIG. 16D). In some embodiments, a stop sleep time can bepredicted based on the intersection of the wake-side 1684 of thecumulative probability curve and threshold 1686 (e.g., 7 AM, asillustrated in FIG. 16D). In other examples, the intersection of thecumulative probability curve and a timeslot can be used.

In some embodiments, there is a single sleep period in every day (e.g.,24 hour period). Thus, there will only be one sleep-side curve(non-decreasing) and one wake-side curve (non-increasing) per sleepperiod. The sleep-side curve (e.g., non-decreasing curve) can bedefined, as the probability a user is asleep before a specific time. Forexample, at time t, a probability curve can be calculated (e.g., asshown above) to predict the start sleep time (e.g., 11 PM). Theprobability can be calculated using cumulative data (e.g., over a 28 dayperiod), and be based on the lock state of the user device (e.g., lockcan equal asleep). The wake-side curve (e.g., non-increasing curve) canbe defined, as the probability a user is awake before a specific time.For example, at time t a probability curve can be calculated (e.g., asshown above) to predict the stop sleep time (e.g., 7 AM). Theprobability can be calculated using cumulative data (e.g., over a 28 dayperiod), and be based on the lock state of the user device (e.g., unlockcan equal awake). The entire sleep probability curve can be calculatedby combining the sleep-side curve and the wake-side curve. Theprobability curve can be determined by calculating the min( )function ofthe sleep-side and wake-side at a particular time t, the cumulativeprobability curve can be calculated, as shown in FIG. 16D. For example,over a 24-hour period, at time 0 (e.g., noon) the sleep-side curve canbe 0% and the wake-side curve can be 100% and at time 12 (e.g.,midnight) the sleep-side curve can be 100% and the wake-side curve canbe 0%.

In some embodiments, to generate a cumulative probability curve, contextdaemon 102 can use the sleep probability threshold value 1686 determinedabove to convert the probabilities (e.g., averages) calculated for each15-minute timeslot into binary (e.g., 1 or 0) values. For example,15-minute timeslots within the sleep period (e.g., greater than sleepthreshold value 1686) can be assigned a value of one (1) and 15-minutetimeslots outside of the sleep period (e.g., less than the sleepthreshold value 1686) can be assigned a value of zero (0). Once binaryvalues are assigned to each 15-minute timeslot, context daemon 102 canfit a curve (e.g., probability curve 1682, 1684) to the binary values.Once generated, context daemon 102 can use probability curve 1682, 1684to estimate the probability that the user will be asleep at a particulartime of day and/or for a particular period of time during a day. Forexample, context daemon 102 can use probability curve 1682, 1684 topredict when the user is likely to be asleep in the future. Referring toFIG. 16D, since the calculated sleep period 1680 represented by graph1675 falls between 11 pm and 7 am, context daemon 102 can predict thatthe user will be asleep between 11 pm and 7 am in the future. Forexample, if the sleep prediction is done on a daily basis (e.g., afterthe user wakes in the morning), context daemon 102 can predict that theuser will sleep between 11 pm and 7 am later in the current day. Thedefinition of a day can be based on a calendar standard, or can be any24 hr period. In some embodiments it can be desirable for the day to beconsidered from 4 pm local time to 3:59 pm local time the next day. Insuch instances, a context daemon 102 can predict the next sleep period,even if it falls within the next day (i.e., after 4 pm local time).

In some embodiments, predicting a future context can be slot-less, i.e.for embodiments where the context is sleep it may not be necessary tomeasure a context in 15 minute increments. For example, when determininga sleep cycle, the day can include only one sleep cycle. Thus, thecomputing device can measure intervals between unlock states and retainonly the longest interval. The interval need not begin or end with thestart of a specific increment or period. This method would be similar tothat described in FIG. 16C and FIG. 16D, wherein sleep curve isdetermined to be the longest interval between unlock states. Each dailysleep curve can be combined into a cumulative curve to be used inpredictions.

Handling Irregularities—Outliers and Missing Data

In some embodiments, context daemon 102 can be configured to handleoutlier data within the historical event stream data. In someembodiments, context daemon 102 can be configured to handle outlier15-minute slots within a block of time that would otherwise correspondto a sleep period. For example, a block of time (e.g., a block ofcontiguous 15-minute slots that have values exceeding the sleepthreshold value and which combined exceed the minimum sleep period) thatmight be a candidate for a sleep period can include a 15-minute slotthat does not exceed the sleep threshold value. For example, if theminimum sleep period is five hours, there are at least twenty 15-minuteslots within the sleep period. When there are twenty 15-minute slots,there can be ten slots that exceed the sleep threshold value, followedby one (e.g., outlier) slot that does not exceed the sleep thresholdvalue, followed by nine slots that exceed the sleep threshold value. Anexample of this scenario can be seen with reference to FIG. 16B whereoutlier slot 1612 does not exceed sleep threshold 1606 and is surroundedby slots (e.g., 1604) that do exceed sleep threshold 1606. When there isa small number (e.g., one, two) outlier 15-minute slot within a block of15-minute slots that exceed the sleep threshold value, then contextdaemon 102 can treat the outlier 15-minute slot as if it exceeded thesleep threshold value so that the sleep period (e.g., sleep curve) canbe generated, as described above. For example, when determining theblock of contiguous 15-minute slots that correspond to the sleep period,context daemon 102 can ignore outlier 15-minute slots. When convertingthe 15-minute slots to binary values to generate the probability curve(as in FIG. 16B), context daemon 102 can assign the outlier 15-minuteslot a value of one so that the probability curve can be generated.

In some embodiments, context daemon 102 can be configured to handleoutlier days (e.g., 24-hour periods, historical data vectors, etc.)within a historical event stream when predicting a sleep period. Forexample, before calculating short-term averages, context daemon 102 cancompare the locked event data (e.g., historical context data) for theprevious seven days. For example, context daemon 102 can perform asimilarity analysis on the historical data vectors for each of theprevious seven 24-hour periods. If the data for one of the seven days(e.g., an outlier day) is completely different than the other six days,then context daemon 102 can remove the outlier day from the short-termaverage calculation. For example, small day-to-day variations inhistorical device lock state data for a 15-minute slot can be normal.However, a shift in a large block of lock data (e.g., corresponding to auser sleep period) can be abnormal. Context daemon 102 can detect theoutlier day by comparing day-to-day patterns in the historical data anddetecting that the use patterns (e.g., user behavior) observed for oneday do not correspond to the use patterns observed for other days in theweek. For example, context daemon 102 can determine that a block of15-minute slots in the outlier day (24-hour period) is unlocked when thesame block of 15-minute slots is typically locked in other days. Oncethe outlier day is detected, context daemon 102 can omit the outlier dayfrom the short-term averaging calculations described above.

Similarly, before calculating long-term averages, context daemon 102 cancompare the locked event data (e.g., historical context data) for thesame day of the week for the previous four weeks, for example. If thedata for one of the days is significantly different than (e.g., anoutlier day) the other four days, then context daemon 102 can remove theoutlier day from the long-term average calculation. For example,week-to-week variations in historical device lock state data for a15-minute slot can be normal. However, a shift in a large block of lockdata (e.g., corresponding to a user sleep period) can be abnormal.Context daemon 102 can detect the outlier day by comparing week-to-weekpatterns in the historical data and detecting that the use patterns(e.g., user behavior) observed for one day do not correspond to the usepatterns observed for the same day in previous weeks. Once the outlierday is detected, context daemon 102 can omit the outlier day from thelong-term averaging calculations described above.

In some embodiments, context daemon 102 can detect an outlier day basedon a shift in user behavior patterns. For example, if a user normallysleeps between 11 pm and 7 am, the historical locked event data willindicate that the device remained (mostly) locked between 11 pm and 7am. However, on an rare day, the user can stay up all night studying orworking, thus the sleep period for that day can shift to another periodof time (e.g., 6 am to 12 pm). In some embodiments, context daemon 102can detect this shift in sleep patterns based on the historical lockedstate data and remove this day from the averaging calculations.

In some embodiments, context daemon 102 can detect an outlier day basedon known or commonly accepted limits in human behavior. For example, theuser could go on a weekend trip and accidently leave the computingdevice (e.g., smartphone) at home for the entire weekend. In this case,the device will remain locked for the whole weekend (e.g., two days)thereby generating a block of locked data that can be erroneouslyinterpreted by context daemon 102 as a sleep period. Context daemon 102can detect this situation by comparing the period of time (e.g., thesleep period) corresponding to the block of locked data to a maximumsleep period (e.g., 12 hours, 24 hours, etc.). For example, the maximumsleep period can be based on common knowledge (e.g., humans do notusually sleep for more than 24 hours) or determined based on observeddata (e.g., the maximum observed sleep period for a user is 10 hours).If the block of time exceeds the maximum sleep period, then contextdaemon 102 can ignore the day or days corresponding to this block oftime when performing the long-term and/or short-term calculationsdescribed above.

In some embodiments, context daemon 102 can be configured to handlemissing data in the historical event stream. For example, a user canturn off the computing device for a period of time or the device canlose battery power after being unplugged from an external power sourcefor a long period of time. While the device is turned off, the devicecannot collect context information and cannot generate a historicalevent stream. When the computing device is turned on again, contextdaemon 102 can attempt to predict future events (e.g., a future sleepperiod) based on the missing data corresponding to the period of timewhen the device was turned off. In this case, context daemon 102 candetermine that no event (e.g., context item) data values exist for thisperiod of time and ignore (e.g., omit) the day or days (e.g., historicaldata vector) corresponding to this period of time when performing theshort-term and/or long-term averaging calculations described above.

Scheduling Activities Based on Predicted Events

FIG. 17 illustrates an example event stream 1700 that includes apredicted future event. For example, using the mechanisms describedabove, context daemon 102 can predict future sleep period 1702. In someembodiments, the predicted future event can be used to scheduleactivities (e.g., context callbacks) within the computing device.Referring to FIG. 1, requesting client 126 can request a callbacknotification in advance of a predicted event. For example, requestingclient 126 can send context daemon 102 a callback request that includesa predicate that specifies that context daemon 102 should notifyrequesting client 126 thirty minutes before the user falls asleep. Whenthe callback request is received, context daemon 102 can schedule thenotification for thirty minutes before the predicted sleep periodbegins. Similarly, requesting client 126 can send context daemon 102 acallback request that includes a predicate that specifies that contextdaemon 102 should notify requesting client 126 one hour after the userfalls asleep. When the callback request is received, context daemon 102can schedule the notification for one hour after the predicted sleepperiod begins.

In some embodiments, context daemon 102 can confirm the prediction of afuture event based on the current context at the predicted time of theevent. For example, if requesting client 126 requests that contextdaemon 102 notify requesting client 126 thirty minutes after thepredicted sleep period begins, context daemon 102 can confirm that theuser is actually asleep at that time by analyzing current context 112(e.g., context item values) to determine whether the device is locked.If the device is unlocked (e.g., the user is not asleep) thirty minutesafter the predicted sleep period began, context daemon 102 will notnotify requesting client 126. In some embodiments, other contextinformation can be used to confirm a predicted sleep period. Forexample, accelerometer state can be used to confirm the sleep period.For example, most smartphone users will place the smartphone on a tableor on the floor when going to sleep. Tables and floors are usuallystationary objects. Thus, the smartphone will not generate much, if any,accelerometer data. If the smartphone is generating accelerometer data,the smartphone is most likely in motion (e.g., in the user's pocketwhile the user is moving). Thus, accelerometer data can indicate thatthe user is moving and not asleep during the predicted sleep period.

In some embodiments, context daemon 102 can improve the prediction offuture events by identifying precursor events. For example, contextdaemon 102 can analyze historical event stream data to identifyrelationships between user activities and predicted events. For example,a user can have a habit of checking an email application, a socialnetworking application, a news application, or another applicationbefore going to sleep. Context daemon 102 can detect these patterns(e.g., using an alarm clock application, then going to sleep) andidentify the precursor application or applications (e.g., emailapplication, clock application, news application, etc.). Once theprecursor application (or applications) has been identified, contextdaemon 102 can use the precursor application to predict that the user isabout to go to sleep. For example, context daemon 102 can determinebased on historical event data that the user typically falls asleep 10minutes after using an alarm clock application. If context daemon 102has predicted that the user will go to sleep at 11 pm and the user isusing the alarm clock application at 10 pm, context daemon 102 canadjust the start of the predicted sleep period from 11 pm to 10:10 pmbased on the precursor alarm clock application activity. In someembodiments, context daemon 102 can adjust the start of the predictedsleep period by adjusting the start and stop times of the predictedsleep period without adjusting the duration of the predicted sleepperiod. In some embodiments, context daemon 102 can adjust the start ofthe predicted sleep period by adjusting the start time and not adjustingthe stop time of the predicted sleep period thereby extending theduration of the predicted sleep period. Alternatively, when contextdaemon 102 detects that the user is using the precursor application(e.g., the current context indicates that the application in focus isthe precursor application), context daemon 102 can monitor the user'sactivity to determine when the user locks the computing device and beginthe current sleep period once the device is locked.

Other Use Cases

In some embodiments, context clients running on the computing device canuse the sleep prediction described above to schedule background taskswhile the user is asleep. For example, an operating system process(e.g., application updater) can need to schedule some system maintenancetasks (e.g., downloading and/or installing application updates) whilethe user is sleeping so that the user is not inconvenienced by theallocation of system resources to system maintenance. Context daemon 102can analyze the state of various device components (e.g., hardware,software, etc.) to determine if the scheduled activity might interferewith any user activity, as described further below.

In some instances, the operating system process can need the user'spasscode (e.g., password) before performing system maintenance tasks.Since the user will be unable to provide the passcode while the user isasleep, the operating system process can request a callback notificationfrom context daemon 102 some time (e.g., 10 minutes) before thepredicted sleep period for the user. Upon receipt of the callbackrequest, context daemon 102 can schedule the callback notification for10 minutes before the predicted sleep period begins. When the scheduledtime arrives (e.g., the current time equals the scheduled time), contextdaemon 102 can send the callback notification to the operating systemprocess. When the operating system process receives the callbacknotification, the operating system process can prompt the user to enterthe user's passcode so that the operating system process can perform themaintenance tasks while the user is asleep. For example, the operatingsystem process can receive the passcode from the user and store thepasscode for use during performance of the system maintenance tasks.Once the system maintenance tasks are completed and the passcode is nolonger needed, the operating system process can delete the user'spasscode from the computing device.

To initiate the maintenance tasks while the user is sleeping, theoperating system process can request a callback notification some time(e.g., 30 minutes) after the predicted sleep period begins. Upon receiptof the callback request, context daemon 102 can schedule the callbacknotification for 45 minutes after the predicted sleep period begins.When the scheduled time arrives (e.g., the current time equals thescheduled time), context daemon 102 can verify that the user is notusing and/or not about to use, the computing device before sending thecallback notification to the operating system process.

In some embodiments, context daemon 102 can verify that the user is notusing the computing device by determining whether the computing deviceis servicing a user-initiated activity. For example, even though thecomputing device is locked (e.g., indicating that the user can besleeping), the computing device can perform navigation relatedactivities in service of a user navigation request. Thus, when contextdaemon 102 determines that navigation components (e.g., globalnavigational satellite system receivers) of the computing device areturned on, context daemon 102 can determine that user is using thecomputing device and cancel or delay sending the callback notificationto the operating system process during the predicted sleep period.Similarly, when context daemon 102 determines that the computing deviceis providing a personal hotspot service, synchronizing data with anotheruser device in response to a user request (e.g., in contrast toautomatic background synchronizations), or providing some other userinitiated service at the time when a callback notification is scheduled,context daemon 102 can cancel or delay sending the callback notificationto the operating system process because the user is still using thecomputing device even though the device is locked.

In some embodiments, context daemon 102 can verify that the user is notabout to use the computing device by determining whether the computingdevice is about to initiate a user-visible activity. For example,various processes running on the computing device can notify the user orget the user's attention. A communication application (e.g., instantmessaging, text messaging, email, telephone, etc.) can remind the userabout a received message. For example, the communication application canbe configured to remind the user to read or respond to a receivedmessage ten minutes after the message was received. A clock applicationcan include an alarm clock function that is configured to notify (e.g.,wake) the user at some future time. A calendar application can beconfigured to remind a user about a scheduled calendar event in thefuture. If the user is scheduled to attend a meeting, a navigationapplication can present a time-to-leave reminder to the user based onthe amount of time it will take the user to travel from the user'scurrent location to the meeting location. An exercise application can beconfigured to remind the user to stand up, walk around, go for a run, ordo some other type of exercise. Each of these notifications, reminders,alerts, etc., is directed to the user and will prompt or cause the userto interact with the computing device. Context daemon 102 can determinewhether one of these user-visible events is about to occur within athreshold period of time (e.g., one minute, ten minutes, an amount oftime needed to complete a system maintenance task, etc.) and delay orcancel sending the callback notification to the operating system processbecause the user is about to start using the computing device.

Processes

FIG. 18 is a flow diagram of an example process 1800 for notifyingclients of context changes on a computing device. For example, acomputing device corresponding to system 100, described above, canperform process 1800.

At step 1802, the computing device can receive a context callbackrequest. For example, context daemon 102 can receive a callback requestfrom requesting client 126, as described above. The callback request caninclude an identifier for requesting client 126 and a predicate thatdefines the context (e.g., device state) conditions under which contextdaemon 102 should send requesting client 126 a callback notification. Insome embodiments, upon receiving the callback request, the contextdaemon 102 can generate a callback identifier that can be used bycontext daemon 102 and/or requesting client 126 to identify the callbackrequest. For example, context daemon 102 can return the callbackidentifier to requesting client 126 in response to receiving thecallback request from requesting client 126. Context daemon 102 canstore the callback request in callback registry 114 and/or predicatedatabase 116, for example.

At step 1804, the computing device can initialize a context monitor toservice the callback request. For example, context daemon 102 can load amonitor bundle 106 (or bundles) corresponding to the context itemsspecified in the callback request predicate, as described above.

At step 1806, the computing device can receive current contextinformation from the context monitor bundle 106 (context monitor 108).For example, each context monitor 108 can interface with various systemcomponents to obtain the state of the system components. The contextmonitors 108 can then report the state to context daemon 102.Alternatively, context daemon 102 can receive state information fromreporting client 124. Context daemon 102 can generate current context112 based on the received state information, as described above.

At step 1808, the computing device can determine that the currentcontext matches the requested context. For example, context daemon 102can compare the context request predicate to the current context todetermine that the current context satisfies the conditions specified inthe predicate.

At step 1810, the computing device can send a callback notification tothe requesting client 126. For example, in response to determining thatthe current context matches the requested context, context daemon 102can send a callback notification to requesting client 126 thatidentifies the callback request. The requesting client 126 can use thecallback request identifier to determine which callback predicatetriggered the callback (e.g., to determine the current operationalcontext of the computing device). Requesting client 126 can then performan action appropriate to the current context.

FIG. 19 is a flow diagram of an example process 1900 for restarting acontext daemon to service a callback request. For example, processesrunning on a computing device can be terminated by a process managerservice of the operating system when the process manager determines thatthe process has been idle for a period of time. When the process manager(or some other process) terminates context daemon 102, the computingdevice can perform process 1900 to restart context daemon 102 so thatcontext daemon 102 can collect context information and send callbacknotifications to requesting client 126. For example, process 1900 cancorrespond to the context daemon restart mechanisms described withreference to FIGS. 7-13.

At step 1902, the computing device can initiate a communication sessionbetween context daemon 102 and requesting client 126. In someembodiments, requesting client 126 can initiate a communication sessionwith context daemon 102 by sending context daemon 102 a callbackrequest, as described above. The callback request can include a clientidentifier and a callback predicate, as described above. In someembodiments, context daemon 102 can only communicate (e.g., send acallback notification) with requesting client 126 using a communicationsession initiated by requesting client 126. In some embodiments, contextdaemon 102 can store the callback request in a callback database (e.g.,predicate database 116).

At step 1904, the computing device can determine that context daemon 102is inactive. For example, when context daemon 102 does not receive anycallback requests or context information updates for a period of time,the process manager can determine that context daemon 102 is idle orinactive.

At step 1906, the computing device can shutdown context daemon 102. Forexample, based on the determination that context daemon 102 is inactive,the process manager can shutdown or terminate context daemon 102 toconserve system resources (e.g., battery power, memory, etc.). Uponshutting down context daemon 102, the communication session betweenrequesting client 126 and context daemon 102 will also be terminated.

At step 1908, the computing device can detect an event associated withcontext daemon 102. For example, the event can be a context client(e.g., requesting client 126, reporting client 124, etc.) sending amessage to context daemon 102. For example, the message can be acallback request from requesting client 126. The message can be acontext information update received from reporting client 124. In someembodiments, the event can be a device state update received by launchdaemon 702 in which context daemon 102 has registered interest.

At step 1910, the computing device can restart context daemon 102. Forexample, when the context client sends a message to the terminatedcontext daemon 102, the computing device can restart context daemon 102so that context daemon 102 can receive and handle the message. Whenlaunch daemon 702 receives a device state update that corresponds to arequest received from context daemon 102, launch daemon 702 can restartcontext daemon 102.

At step 1912, the computing device can restore registered callbackrequests to callback daemon 102. For example, once restarted, callbackdaemon 102 can restore the callback requests received before callbackdaemon 102 was terminated. For example, callback daemon 102 can restorethe previously received callback from the callback predicate database(e.g., predicate database 116).

At step 1914, the computing device can initialize the event monitorsrequired for servicing the restored callback requests. For example,context daemon 102 can load the event monitor bundles 106 necessary forcollecting the context information needed to service the callbackrequests.

At step 1916, the computing device can reestablish the communicationsession between context daemon 102 and requesting client 126. Forexample, once context daemon 102 is running again, the requesting client126 can send a message (e.g., callback request) to context daemon 102 toreestablish the communication session. Context daemon 102 can use thereestablished communication session to send callback notifications tothe client according to the predicate specified in the callback request.

FIG. 20 is a flow diagram of an example process 2000 for restarting acallback client to receive a callback notification. For example,processes running on a computing device can be terminated by a processmanager service of the operating system when the process managerdetermines that the process has been idle for a period of time. When theprocess manager (or some other process) terminates requesting client126, the computing device can perform process 1900 to restart requestingclient 126 so that requesting client 126 can receive callbacknotifications from context daemon 102. For example, process 2000 cancorrespond to the requesting client restart mechanisms described withreference to FIGS. 7-13.

At step 2002, the computing device can initiate a communication sessionbetween context daemon 102 and requesting client 126. In someembodiments, requesting client 126 can initiate a communication sessionwith context daemon 102 by sending context daemon 102 a callbackrequest, as described above. The callback request can include a clientidentifier and a callback predicate, as described above. In someembodiments, context daemon 102 can only communicate (e.g., send acallback notification) with requesting client 126 using a communicationsession initiated by requesting client 126. In some embodiments, contextdaemon 102 can store the callback request in a callback predicatedatabase (e.g., predicate database 116).

At step 2004, the computing device can determine that requesting client126 is inactive. For example, when requesting client 126 is notperforming significant processing (e.g., CPU usage for requesting client126 is below a threshold level) within the computing device, the processmanager can determine that requesting client 126 is idle or inactive.

At step 2006, the computing device can shutdown requesting client 126.For example, based on the determination that requesting client 126 isinactive, the process manager can shutdown or terminate requestingclient 126 to conserve system resources (e.g., battery power, memory,etc.). Upon shutting down requesting client 126, the communicationsession between requesting client 126 and context daemon 102 will alsobe terminated. Thus, context daemon 102 will not have a communicationchannel by which to deliver callback notifications to requesting client126.

At step 2008, the computing device can detect an event associated withrequesting client 126. For example, context daemon 102 can detect acurrent context that matches the context callback predicate (e.g.,corresponds to the conditions specified by the predicate). Launch daemon702 can detect a device state that corresponds to a device state requestreceived from context daemon 102 and associated with the clientidentifier of context client 126.

At step 2010, the computing device can restart requesting client 126.For example, when context daemon 102 detects that the current contextmatches the context callback predicate, context daemon 102 can attemptto send a callback notification to requesting client 126. However,because the communication session between context daemon 102 andrequesting client 126 was terminated, context daemon 102 cannot send thecallback notification to the requesting client 126. Thus, upon detectingthat the communication channel with requesting client 126 has beenterminated, context daemon 102 can send the client identifier receivedfrom requesting client 126 to launch daemon 702 in a request to restartrequesting client 126. In some embodiments, upon requesting launchdaemon 702 restart requesting client 126, context daemon 102 can deleteall callback request data (e.g., stored in callback registry 114 and/orpredicate database 116) associated with the client identifier ofrequesting client 126. Upon receiving the client identifier, launchdaemon 702 can restart requesting client 126. Alternatively, upondetecting a device state that corresponds to a device state requestreceived from context daemon 102 and associated with the clientidentifier of context client 126, launch daemon 702 can restartrequesting client 126.

At step 2012, the computing device can reestablish a communicationsession between context daemon 102 and requesting client 126. Forexample, upon restarting, requesting client 126 can send a new callbackrequest to context daemon 102 to start a new communication session.

At step 2014, the computing device can receive a client callback requestfrom the restarted requesting client 126. For example, context daemon102 can receive the callback request from requesting client 126 thatspecifies the same callback predict corresponding to the current contextas described at step 2008. Upon receipt of the callback request, contextdaemon 102 can determine that the callback request corresponds to thecurrent context of the computing device.

At step 2016, the computing device can send a callback notification torequesting client 126. For example, upon determining that the currentcontext matches the callback request, context daemon 102 can send acallback notification to requesting client 126 using the reestablishedcommunication channel.

FIG. 21 is a flow diagram of an example process 2100 for predictingfuture events based on historical context information. For example,process 2100 can correspond to the event prediction mechanisms describedwith reference to FIGS. 14-17.

At step 2102, the computing device can obtain historical context datafor a context item. For example, context daemon 102 (e.g., usinghistorical monitor 110) can generate a historical event stream for eachcontext item in current context 112 that indicates changes in devicecontext (e.g., device state) over time. For example, historical monitor110 can generate a historical event stream for the “locked” context itemindicating when the device was locked or unlocked, as described above.

At step 2104, the computing device can generate historical context datavectors for the context item. For example, context daemon 102 cananalyze the historical context data for a context item in 24-hourperiods over the previous 28 days. For example, context daemon 102 cangenerate 28 data vectors for each of the 28 previous 24-hour periods.Each of the 28 data vectors can include 96 data entries (e.g., eachvector can have a length of 96) corresponding to the 96 15-minute slotsin each 24-hour period. Context daemon 102 can assign to each of the 9615-minute slots a probability value that corresponds to the observedvalue of the context item (e.g., device state) recorded during each ofthe 28 previous 24-hour periods (e.g., previous 28 days). For example,context daemon 102 can assign to each of the 96 data slots in the 28vectors a value (e.g., 0, 1, 0.45, etc.) that indicates the likelihoodthat the computing device will remain locked during each of the 9615-minute slots in the previous 28 days.

At step 2106, the computing device can determine a short-termprobability that a particular context value will or can occur in eachtime slot. For example, the short-term probability can be calculatedbased on data collected over a previous number of days. For example,context daemon 102 can calculate the short-term probability (P_(S)) thatthe device will remain locked by averaging the 15-minute slots over theprevious seven days, as described above in the “Short-Term Averaging”section above.

At step 2108, the computing device can determine a long-term probabilitythat a particular context value will or can occur in each time slot. Forexample, the long-term probability can be calculated based on datacollected on the same day of the week (e.g., Sunday, Wednesday, etc.)over a previous number of weeks. For example, context daemon 102 cancalculate the long-term probability (P_(L)) that the device will remainlocked by averaging the 15-minute slots over the previous four weeks, asdescribed above in the “Long-Term Averaging” section above.

At step 2110, the computing device can combine the short-term andlong-term probabilities to generate a combined probability. For example,context daemon 102 can combine the short-term probability (P_(S)) andthe long-term probability (P_(L)) to generate a combined probability(P), as described above. In some embodiments, context daemon 102 canweight the long-term probability (or short-term probability) to adjustthe impact that the long-term probability has on the combinedprobability.

At step 2112, the computing device can generate a probability curve forthe context item value. For example, context daemon 102 can convert theslot-wise probability values into a probability curve, as described inthe “Generating a Sleep Curve” section above.

At step 2114, the computing device can predict the future occurrence ofthe particular device context. For example, once the probability curveis generated, context daemon 102 can predict the occurrence of the samecontext item value in the future based on the probability curve. Forexample, using the locked context example above, context daemon 102 canpredict that the device will remained locked during the hours of 11 pmand 7 am. Based on this locked context item prediction, context daemon102 can infer that the user will be asleep during this predicted timeperiod.

FIG. 22 is a flow diagram of an example process 2200 for servicing asleep context callback request. For example, process 2200 can correspondto the mechanisms described in at least FIG. 21 above. For example,requesting client 126 (e.g., an application, utilities, operating systemtool, etc.,) can send a callback request to context daemon 102specifying that context daemon 102 should notify the processes when theuser is sleeping. For example, requesting client 126 can be configuredto schedule maintenance activities while the user sleeps so that theuser is not inconvenienced by these maintenance activities while usingthe computing device.

At step 2202, the computing device can receive a sleep context callbackrequest. For example, context daemon 102 can receive a callback requestfrom requesting client 126 specifying that context daemon 102 shouldnotify requesting client 126 ten minutes after the user goes to sleep.

At step 2204, the computing device can initialize a sleep contextmonitor to service the callback request. For example, the sleep contextmonitor can be a monitor bundle 106 that includes a context monitor 108configured to monitor the locked state of the computing device. In someinstances, context monitor 108 can be configured to monitor the lockedstate of the computing device and the state of other componentsassociated with the sleep context. For example, context monitor 108 canmonitor the state of navigation components, wireless networkingcomponents (e.g., personal hotspot, Bluetooth, etc.), devicesynchronization components, and/or device input/output components (e.g.,headphones jack connector, etc.).

At step 2206, the computing device can receive sleep context informationfrom the context monitor. For example, the context monitor 108 canreport the locked state of the computing device and/or the state of theother monitored components to context daemon 102.

At step 2208, the computing device can predict a future sleep period.For example, context daemon 102 can predict a future sleep period asdescribed above with reference to FIG. 21.

At step 2210, the computing device can schedule the sleep contextcallback. For example, if the predicted sleep period is from 11 pm to 7am and the sleep context callback specifies that requesting client 126should be called back ten minutes after the sleep period begins, thencontext daemon 102 can schedule the sleep callback for 11:10 pm.

At step 2212, the computing device can process the scheduled sleepcontext callback. For example, context daemon 102 can detect when thecurrent time equals the scheduled 11:10 pm time and determine whether tosend a callback notification to requesting client 126.

At step 2214, the computing device can determine whether the user issleeping. For example, context daemon 102 can analyze various contextitems (e.g., device state) to confirm that the user is sleeping. In someembodiments, context daemon 102 can determine whether the current devicelocked state indicates that the device is locked. If the device is notlocked, context daemon 102 can cancel or delay sending the sleepcallback notification to requesting client 126.

In some embodiments, context daemon 102 can determine whether the useris passively using the computing device. For example, the user can beusing (e.g., relying upon) the device without providing user input orunlocking the device. If the user is passively using the computingdevice, context daemon 102 can cancel or delay sending the sleepcallback notification to requesting client 126. For example, the usercan be using the navigation features of the computing device while thedevice is locked. Thus, context daemon 102 can determine whether thenavigational components (e.g., GNSS system, Wi-Fi and/or cellular datatransceivers, etc.) are turned on. If the current context informationindicates that these navigational components are powered, then contextdaemon 102 can determine that the user is passively using the computingdevice and is not asleep.

As another example of passive use, the user might be using personalhotspot functionality provided by the computing device while thecomputing device is locked. If the current context information indicatesthat the personal hotspot components are active, then context daemon 102can determine that the user is passively using the computing device andis not asleep.

As another example of passive use, the user might have initiated asynchronization operation with another device (e.g., a laptop, tabletcomputer, smart watch, etc.). The synchronization operation can beperformed while the computing device is locked. If the current contextinformation indicates that the computing device is performing asynchronization operation, then context daemon 102 can determine thatthe user is passively using the computing device and is not asleep.

At step 2216, the computing device can confirm that no imminent useractivity is scheduled to occur. For example, the user can in fact beasleep but the computing device can have scheduled a user-visiblenotification to occur soon that will wake up the user and cause the userto use the computing device. For example, the computing device can havescheduled a reminder about an incoming communication (e.g., textmessage, instant message, email, telephone call, etc.) that is scheduledto happen soon after the sleep callback notification is scheduled. Thecomputing device can have scheduled an alarm (e.g., an alarm clock app)that is scheduled to happen soon after the sleep callback notificationis scheduled. The computing device can have scheduled a calendarreminder or alert that is scheduled to happen soon after the sleepcallback notification is scheduled. The computing device can havescheduled a time-to-leave notification that is scheduled to happen soonafter the sleep callback notification is scheduled. The computing devicecan have scheduled an exercise reminder that is scheduled to happen soonafter the sleep callback notification is scheduled. If context daemon102 determines that user activity is scheduled to occur within athreshold period of time (e.g., 1 minute, 5 minutes, etc.), then contextdaemon 102 can cancel or delay sending the sleep callback notificationto requesting client 126.

At step 2212, the computing device can send the sleep callbacknotification to the client. For example, when context daemon 102confirms that the user is sleeping at step 2214 and confirms that thereis no imminent user activity scheduled at step 2216, context daemon 102can send the sleep callback notification to requesting client 126.

Example System Architectures

FIG. 23A and FIG. 23B show example system architectures for implementingthe systems and processes described above. The more appropriatearchitecture will be apparent to those of ordinary skill in the art whenimplementing the systems and processes described above. Persons ofordinary skill in the art will also readily appreciate that other systemarchitectures are possible.

FIG. 23A illustrates a conventional system bus computing systemarchitecture 2300 wherein the components of the system are in electricalcommunication with each other using a bus 2305. Example system 2300includes a processing unit (CPU or processor) 2310 and a system bus 2305that couples various system components including the system memory 2315,such as read only memory (ROM) 2320 and random access memory (RAM) 2325,to the processor 2310. The system 2300 can include a cache of high-speedmemory connected directly with, in close proximity to, or integrated aspart of the processor 2310. The system 2300 can copy data from thememory 2315 and/or the storage device 2330 to the cache 2312 for quickaccess by the processor 2310. In this way, the cache can provide aperformance boost that avoids processor 2310 delays while waiting fordata. These and other modules can control or be configured to controlthe processor 2310 to perform various actions. Other system memory 2315can be available for use as well. The memory 2315 can include multipledifferent types of memory with different performance characteristics.The processor 2310 can include any general purpose processor and ahardware module or software module, such as module 1 2332, module 22334, and module 3 2336 stored in storage device 2330, configured tocontrol the processor 2310 as well as a special-purpose processor wheresoftware instructions are incorporated into the actual processor design.The processor 2310 can essentially be a completely self-containedcomputing system, containing multiple cores or processors, a bus, memorycontroller, cache, etc. A multi-core processor can be symmetric orasymmetric.

To enable user interaction with the computing device 2300, an inputdevice 2345 can represent any number of input mechanisms, such as amicrophone for speech, a touch-sensitive screen for gesture or graphicalinput, keyboard, mouse, motion input, speech and so forth. An outputdevice 2335 can also be one or more of a number of output mechanismsknown to those of skill in the art. In some instances, multimodalsystems can enable a user to provide multiple types of input tocommunicate with the computing device 2300. The communications interface2340 can generally govern and manage the user input and system output.There is no restriction on operating on any particular hardwarearrangement and therefore the basic features here can easily besubstituted for improved hardware or firmware arrangements as they aredeveloped.

Storage device 2330 is a non-volatile memory and can be a hard disk orother types of computer readable media which can store data that areaccessible by a computer, such as magnetic cassettes, flash memorycards, solid state memory devices, digital versatile disks, cartridges,random access memories (RAMs) 2325, read only memory (ROM) 2320, andhybrids thereof.

The storage device 2330 can include software modules 2332, 2334, 2336for controlling the processor 2310. Other hardware or software modulesare contemplated. The storage device 2330 can be connected to the systembus 2305. In one aspect, a hardware module that performs a particularfunction can include the software component stored in acomputer-readable medium in connection with the necessary hardwarecomponents, such as the processor 2310, bus 2305, display 2335, and soforth, to carry out the function.

FIG. 23B illustrates a computer system 2350 having a chipsetarchitecture that can be used in executing the described method andgenerating and displaying a graphical user interface (GUI). Computersystem 2350 is an example of computer hardware, software, and firmwarethat can be used to implement the disclosed technology. System 2350 caninclude a processor 2355, representative of any number of physicallyand/or logically distinct resources capable of executing software,firmware, and hardware configured to perform identified computations.Processor 2355 can communicate with a chipset 2360 that can controlinput to and output from processor 2355. In this example, chipset 2360outputs information to output 2365, such as a display, and can read andwrite information to storage device 2370, which can include magneticmedia, and solid state media, for example. Chipset 2360 can also readdata from and write data to RAM 2375. A bridge 2380 for interfacing witha variety of user interface components 2385 can be provided forinterfacing with chipset 2360. Such user interface components 2385 caninclude a keyboard, a microphone, touch detection and processingcircuitry, a pointing device, such as a mouse, etc. In general, inputsto system 2350 can come from any of a variety of sources, machinegenerated and/or human generated.

Chipset 2360 can also interface with one or more communicationinterfaces 2390 that can have different physical interfaces. Suchcommunication interfaces can include interfaces for wired and wirelesslocal area networks, for broadband wireless networks, as well aspersonal area networks. Some applications of the methods for generating,displaying, and using the GUI disclosed herein can include receivingordered datasets over the physical interface or be generated by themachine itself by processor 2355 analyzing data stored in storage 2370or 2375. Further, the machine can receive inputs from a user via userinterface components 2385 and execute appropriate functions, such asbrowsing functions by interpreting these inputs using processor 2355.

Example systems 2300 and 2350 can have more than one processor (e.g.,processor 2310 and/or processor 2355) or be part of a group or clusterof computing devices networked together to provide greater processingcapability.

For clarity of explanation, in some instances the present technology canbe presented as including individual functional blocks includingfunctional blocks comprising devices, device components, steps orroutines in a method embodied in software, or combinations of hardwareand software.

In some embodiments the computer-readable storage devices, mediums, andmemories can include a cable or wireless signal containing a bit streamand the like. However, when mentioned, non-transitory computer-readablestorage media expressly exclude media such as energy, carrier signals,electromagnetic waves, and signals per se.

Methods according to the above-described examples can be implementedusing computer-executable instructions that are stored or otherwiseavailable from computer readable media. Such instructions can comprise,for example, instructions and data which cause or otherwise configure ageneral purpose computer, special purpose computer, or special purposeprocessing device to perform a certain function or group of functions.Portions of computer resources used can be accessible over a network.The computer executable instructions can be, for example, binaries,intermediate format instructions such as assembly language, firmware, orsource code. Examples of computer-readable media that can be used tostore instructions, information used, and/or information created duringmethods according to described examples include magnetic or opticaldisks, flash memory, USB devices provided with non-volatile memory,networked storage devices, and so on.

Devices implementing methods according to these disclosures can comprisehardware, firmware and/or software, and can take any of a variety ofform factors. Typical examples of such form factors include laptops,smart phones, small form factor personal computers, personal digitalassistants, and so on. Functionality described herein also can beembodied in peripherals or add-in cards. Such functionality can also beimplemented on a circuit board among different chips or differentprocesses executing in a single device, by way of further example.

The instructions, media for conveying such instructions, computingresources for executing them, and other structures for supporting suchcomputing resources are means for providing the functions described inthese disclosures.

Although a variety of examples and other information was used above toexplain aspects within the scope of the appended claims, no limitationof the claims should be implied based on particular features orarrangements in such examples, as one of ordinary skill would be able touse these examples to derive a wide variety of embodiments. Further andalthough some subject matter may have been described in languagespecific to examples of structural features and/or method steps, it isto be understood that the subject matter defined in the appended claimsis not necessarily limited to these described features or acts. Forexample, such functionality can be distributed differently or performedin components other than those identified herein. Rather, the describedfeatures and steps are disclosed as examples of components of systemsand methods within the scope of the appended claims.

What is claimed is:
 1. A method comprising: receiving, at a contextdaemon process executing on a computing device, a first context callbackrequest from a context client, the context callback request initiating afirst communication session between the context client and the contextdaemon; receiving, by the context daemon, current context information;determining that the current context information corresponds to thecontext callback request; in response to the determining, detecting, bythe context daemon, that the first communication session with thecontext client has terminated; and in response to the detecting,sending, by the context daemon, a restart message to a launch daemonrequesting that the launch daemon restart the context client.
 2. Themethod of claim 1, wherein the callback request includes a clientidentifier, and further comprising: sending, by the context daemon, theclient identifier to the launch daemon in the message.
 3. The method ofclaim 1, wherein the current context information includes one or morecontext items that describe a current state of the computing device. 4.The method of claim 1, wherein the context callback request specifiesconditions for notifying the context client based on the current contextinformation received by the context daemon.
 5. The method of claim 1,further comprising: terminating the context client after the contextdaemon receives the first context callback request.
 6. The method ofclaim 5, further comprising: upon receipt of the restart message,restarting, by the launch daemon, the context client; after the clienthas been restarted, receiving, by the context daemon, a second contextcallback request from the context client; comparing the second contextcallback request to the current context information; and in response tothe comparing, notifying the context client that the current contextinformation corresponds to the second context callback request.
 7. Themethod of claim 1, wherein the second context callback requestestablishes a second communication session between the context clientand the context daemon and wherein the context daemon uses the secondcommunication session established by the context client to notify thecontext client.
 8. A computing device for efficient context monitoringcomprising: a context daemon process, which when executed on thecomputing device, causes the context daemon process to: receive a firstcontext callback request from a context client, the context callbackrequest initiating a first communication session between the contextclient and the context daemon; receive current context information;determine that the current context information corresponds to thecontext callback request; detect, in response to the determination, thatthe first communication session with the context client has terminated;and send, in response to the detection, a restart message to a launchdaemon requesting that the launch daemon restart the context client. 9.The computing device of claim 8, wherein the callback request includes aclient identifier, and the context daemon process is further executedto: send the client identifier to the launch daemon in the message. 10.The computing device of claim 8, wherein the current context informationincludes one or more context items that describe a current state of thecomputing device.
 11. The computing device of claim 8, wherein thecontext callback request specifies conditions for notifying the contextclient based on the current context information received by the contextdaemon.
 12. The computing device of claim 8, further comprising thecontext daemon process executed to: terminate the context client afterthe context daemon receives the first context callback request.
 13. Thecomputing device of claim 12, further comprising the context daemonprocess executed to: upon receipt of the restart message, restart, bythe launch daemon, the context client; after the client has beenrestarted, receive a second context callback request from the contextclient; compare the second context callback request to the currentcontext information; and in response to the comparison, notify thecontext client that the current context information corresponds to thesecond context callback request.
 14. The computing device of claim 8,wherein the second context callback request establishes a secondcommunication session between the context client and the context daemonand wherein the context daemon uses the second communication sessionestablished by the context client to notify the context client.
 15. Anon-transitory computer-readable medium containing instructions that,when executed by a computing device, cause a context daemon process ofthe computing device to: receive a first context callback request from acontext client, the context callback request initiating a firstcommunication session between the context client and the context daemon;receive current context information; determine that the current contextinformation corresponds to the context callback request; detect, inresponse to the determination, that the first communication session withthe context client has terminated; and send, in response to thedetection, a restart message to a launch daemon requesting that thelaunch daemon restart the context client.
 16. The non-transitorycomputer-readable medium of claim 15, wherein the callback requestincludes a client identifier, and further instructions which whenexecuted cause the context daemon process to: send the client identifierto the launch daemon in the message.
 17. The non-transitorycomputer-readable medium of claim 15, wherein the current contextinformation includes one or more context items that describe a currentstate of the computing device.
 18. The non-transitory computer-readablemedium of claim 15, wherein the context callback request specifiesconditions for notifying the context client based on the current contextinformation received by the context daemon.
 19. The computing device ofclaim 15, further comprising instructions, which when executed, causethe context daemon process to: terminate the context client after thecontext daemon receives the first context callback request.
 20. Thenon-transitory computer-readable medium of claim 19, further comprisinginstructions, which when executed cause the context daemon process to:upon receipt of the restart message, restart, by the launch daemon, thecontext client; after the client has been restarted, receive a secondcontext callback request from the context client; compare the secondcontext callback request to the current context information; and inresponse to the comparison, notify the context client that the currentcontext information corresponds to the second context callback request.